kinetic-mcp 1.2.0 → 1.2.3

package/scripts/setup.mjs

@@ -1,42 +1,100 @@
 #!/usr/bin/env node
 
 /**
- * Interactive setup wizard for Solana Trading MCP Server.
+ * Interactive setup wizard for Kinetic MCP Server.
  *
- * Run: npm run setup
+ * Run: npx kinetic-mcp setup
  *
  * This is a standalone .mjs file — no compilation required.
- * Uses only Node built-ins + @solana/web3.js (already installed) + bs58 (transitive dep).
+ * Uses @clack/prompts for beautiful terminal UI.
  */
 
-import { createInterface } from "node:readline/promises";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, copyFileSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  chmodSync,
+  copyFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve, dirname } from "node:path";
 import { execSync } from "node:child_process";
-import { stdin, stdout, platform, execPath } from "node:process";
+import { platform, execPath } from "node:process";
+import { createRequire } from "node:module";
+
 import { Keypair } from "@solana/web3.js";
 import bs58 from "bs58";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
 
 // ---------------------------------------------------------------------------
-// Helpers
+// Version
+// ---------------------------------------------------------------------------
+
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+
+// ---------------------------------------------------------------------------
+// Non-TTY check
 // ---------------------------------------------------------------------------
 
-const MAX_RETRIES = 3;
+if (!process.stdin.isTTY) {
+  console.error("Error: Setup wizard requires an interactive terminal.");
+  console.error("Run: npx kinetic-mcp setup");
+  process.exit(1);
+}
 
-const rl = createInterface({ input: stdin, output: stdout });
+// ---------------------------------------------------------------------------
+// ASCII Banner
+// ---------------------------------------------------------------------------
 
-function expandHome(p) {
-  if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return resolve(homedir(), p.slice(2));
+const BANNER = `
+ ██╗  ██╗██╗███╗   ██╗███████╗████████╗██╗ ██████╗
+ ██║ ██╔╝██║████╗  ██║██╔════╝╚══██╔══╝██║██╔════╝
+ █████╔╝ ██║██╔██╗ ██║█████╗     ██║   ██║██║
+ ██╔═██╗ ██║██║╚██╗██║██╔══╝     ██║   ██║██║
+ ██║  ██╗██║██║ ╚████║███████╗   ██║   ██║╚██████╗
+ ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚══════╝   ╚═╝   ╚═╝ ╚═════╝`;
+
+async function renderBanner() {
+  let rendered;
+  try {
+    const gradient = (await import("gradient-string")).default;
+    const kineticGradient = gradient(["#FEDA75", "#FA7E1E", "#D62976", "#962FBF", "#4F5BD5"]);
+    rendered = kineticGradient.multiline(BANNER);
+  } catch {
+    rendered = pc.bold(pc.magenta(BANNER));
   }
-  return p;
+
+  console.log(rendered);
+  console.log(pc.dim(`  v${version} — Solana Trading via Claude Desktop`));
+  console.log();
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+function expandHome(filePath) {
+  if (filePath.startsWith("~/") || filePath.startsWith("~\\")) {
+    return resolve(homedir(), filePath.slice(2));
+  }
+  return filePath;
 }
 
 function isWSL() {
   try {
-    const version = readFileSync("/proc/version", "utf-8");
-    return /microsoft|wsl/i.test(version);
+    const ver = readFileSync("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(ver);
   } catch {
     return false;
   }
@@ -48,11 +106,13 @@ function getClaudeConfigPath() {
     case "darwin":
       return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
     case "win32":
-      return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+      return join(
+        process.env.APPDATA || join(home, "AppData", "Roaming"),
+        "Claude",
+        "claude_desktop_config.json",
+      );
     case "linux":
-      if (isWSL()) {
-        return null; // WSL handled separately
-      }
+      if (isWSL()) return null;
       return join(home, ".config", "Claude", "claude_desktop_config.json");
     default:
       return null;
@@ -63,81 +123,6 @@ function getDefaultKeypairPath() {
   return join(homedir(), ".config", "solana", "trading-keypair.json");
 }
 
-/** Read a line with masked input (asterisks). Falls back to plain input on non-TTY. */
-function readMasked(prompt) {
-  return new Promise((resolve, reject) => {
-    stdout.write(prompt);
-
-    if (!stdin.isTTY) {
-      // Non-interactive: read without masking
-      const lineRl = createInterface({ input: stdin });
-      lineRl.on("line", (line) => {
-        lineRl.close();
-        resolve(line.trim());
-      });
-      return;
-    }
-
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding("utf8");
-    let input = "";
-
-    const onData = (ch) => {
-      if (ch === "\r" || ch === "\n") {
-        stdin.setRawMode(false);
-        stdin.pause();
-        stdin.removeListener("data", onData);
-        stdout.write("\n");
-        resolve(input);
-      } else if (ch === "\u0003") {
-        // Ctrl+C
-        stdin.setRawMode(false);
-        stdin.pause();
-        stdin.removeListener("data", onData);
-        stdout.write("\n");
-        reject(new Error("Cancelled by user"));
-      } else if (ch === "\u007f" || ch === "\b") {
-        // Backspace
-        if (input.length > 0) {
-          input = input.slice(0, -1);
-          stdout.write("\b \b");
-        }
-      } else if (ch.charCodeAt(0) >= 32) {
-        // Printable character
-        input += ch;
-        stdout.write("*");
-      }
-    };
-
-    stdin.on("data", onData);
-  });
-}
-
-async function askYesNo(question, defaultYes = true) {
-  const suffix = defaultYes ? "(Y/n)" : "(y/N)";
-  const answer = await rl.question(`${question} ${suffix} `);
-  const trimmed = answer.trim().toLowerCase();
-  if (trimmed === "") return defaultYes;
-  return trimmed === "y" || trimmed === "yes";
-}
-
-async function askChoice(question, choices) {
-  console.log(`\n${question}`);
-  choices.forEach((c, i) => console.log(`  ${i + 1}. ${c}`));
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    const answer = await rl.question(`Choice (1-${choices.length}): `);
-    const num = parseInt(answer.trim(), 10);
-    if (num >= 1 && num <= choices.length) return num;
-    console.log("  Invalid choice. Try again.");
-  }
-  throw new Error("Too many invalid attempts.");
-}
-
-// ---------------------------------------------------------------------------
-// Keypair handling
-// ---------------------------------------------------------------------------
-
 function validateKeypairFile(filePath) {
   const expanded = expandHome(filePath);
   if (!existsSync(expanded)) {
@@ -148,112 +133,304 @@ function validateKeypairFile(filePath) {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new Error("File is not valid JSON. Expected a JSON array of 64 integers (Solana CLI format).");
+    throw new Error(
+      "File is not valid JSON. Expected a JSON array of 64 integers (Solana CLI format).",
+    );
   }
   if (
     !Array.isArray(parsed) ||
     parsed.length !== 64 ||
     !parsed.every((n) => typeof n === "number" && Number.isInteger(n))
   ) {
-    throw new Error("File does not contain a valid Solana keypair. Expected a JSON array of exactly 64 integers.");
+    throw new Error("Invalid Solana keypair. Expected a JSON array of exactly 64 integers.");
   }
   return Keypair.fromSecretKey(Uint8Array.from(parsed));
 }
 
-async function importFromPhantom() {
-  console.log("\n--- Import Private Key from Phantom ---");
-  console.log("");
-  console.log("  How to export from Phantom:");
-  console.log("  1. Open Phantom > Settings > Security & Privacy > Export Private Key");
-  console.log("  2. Enter your password and copy the base58 string");
-  console.log("");
-  console.log("  SECURITY: Your key will be masked. It is NOT saved to shell history.");
-  console.log("");
-
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    try {
-      const key = await readMasked("  Paste your private key: ");
-      if (!key || key.trim().length === 0) {
-        console.log("  No key entered. Try again.");
-        continue;
-      }
+// ---------------------------------------------------------------------------
+// Step 2: Build Check
+// ---------------------------------------------------------------------------
 
-      let decoded;
-      try {
-        decoded = bs58.decode(key.trim());
-      } catch {
-        console.log("  Invalid private key format. Expected a base58-encoded string from Phantom.");
-        continue;
-      }
+async function checkBuild() {
+  const buildExists = existsSync(resolve("build", "index.js"));
+  if (buildExists) return;
 
-      if (decoded.length !== 64) {
-        console.log(`  Expected 64-byte secret key, got ${decoded.length} bytes.`);
-        if (decoded.length === 32) {
-          console.log("  This looks like a 32-byte seed. Use the Solana CLI to generate the full keypair.");
-        }
-        continue;
-      }
+  p.log.warn("Project hasn't been built yet — build/index.js not found.");
 
-      const keypair = Keypair.fromSecretKey(decoded);
-      console.log(`\n  Wallet address: ${keypair.publicKey.toBase58()}`);
-      console.log("  Verify this matches your Phantom wallet address.");
+  const runBuild = handleCancel(
+    await p.confirm({ message: "Run npm run build now?", initialValue: true }),
+  );
 
-      // Save keypair file
-      const defaultPath = getDefaultKeypairPath();
-      const answer = await rl.question(`\n  Save keypair to (${defaultPath}): `);
-      const savePath = expandHome(answer.trim() || defaultPath);
+  if (runBuild) {
+    const s = p.spinner();
+    s.start("Building project...");
+    try {
+      execSync("npm run build", { stdio: "pipe" });
+      s.stop("Build complete");
+    } catch {
+      s.stop("Build failed");
+      p.log.warn("You can try again later with: npm run build");
+    }
+  } else {
+    p.log.info("Skipped. Remember to run npm run build before using the server.");
+  }
+}
 
-      mkdirSync(dirname(savePath), { recursive: true });
-      writeFileSync(savePath, JSON.stringify(Array.from(keypair.secretKey)) + "\n");
+// ---------------------------------------------------------------------------
+// Step 3: Keypair Setup
+// ---------------------------------------------------------------------------
 
-      // Set permissions on Unix
-      if (platform !== "win32") {
+async function importFromPhantom() {
+  p.note(
+    [
+      `${pc.bold("How to export from Phantom:")}`,
+      "",
+      "1. Open Phantom → Settings → Manage Accounts → [Your Account] → Show Private Key",
+      "2. Enter your password and copy the base58 string",
+      "",
+      `${pc.dim("Your key will be masked. It is NOT saved to shell history.")}`,
+    ].join("\n"),
+    "Import Private Key",
+  );
+
+  const key = handleCancel(
+    await p.password({
+      message: "Paste your private key:",
+      mask: "*",
+      validate(value) {
+        if (!value || value.trim().length === 0) return "Private key is required.";
+
+        let decoded;
         try {
-          chmodSync(savePath, 0o600);
+          decoded = bs58.decode(value.trim());
         } catch {
-          // Non-fatal — permissions may not be settable on all filesystems
+          return "Invalid format. Expected a base58-encoded string from Phantom.";
         }
-      }
 
-      console.log(`  Keypair saved to: ${savePath}`);
-      return { keypair, path: savePath };
-    } catch (err) {
-      if (err.message === "Cancelled by user") throw err;
-      console.log(`  Error: ${err.message}`);
+        if (decoded.length !== 64) {
+          if (decoded.length === 32) {
+            return "This looks like a 32-byte seed. Use the Solana CLI to generate the full keypair.";
+          }
+          return `Expected 64-byte secret key, got ${decoded.length} bytes.`;
+        }
+      },
+    }),
+  );
+
+  const decoded = bs58.decode(key.trim());
+  const keypair = Keypair.fromSecretKey(decoded);
+
+  const publicKey = keypair.publicKey.toBase58();
+  p.log.info(`Wallet address: ${pc.cyan(publicKey)}`);
+  p.log.message(pc.dim("Verify this matches your Phantom wallet address."));
+
+  // Save keypair to default path
+  const defaultPath = getDefaultKeypairPath();
+
+  // Check if file exists
+  if (existsSync(defaultPath)) {
+    const overwrite = handleCancel(
+      await p.confirm({
+        message: `Keypair file already exists at ${pc.dim(defaultPath)}. Overwrite?`,
+        initialValue: false,
+      }),
+    );
+
+    if (!overwrite) {
+      p.log.info("Keeping existing keypair file.");
+      return { publicKey, path: defaultPath };
     }
   }
-  throw new Error("Too many invalid attempts. Exiting.");
-}
 
-async function useExistingKeypair() {
-  console.log("\n--- Use Existing Keypair File ---");
-  console.log("  Expected format: JSON array of 64 integers (Solana CLI format).");
-  console.log("");
-
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    const filePath = await rl.question("  Path to keypair file: ");
-    if (!filePath.trim()) {
-      console.log("  No path entered. Try again.");
-      continue;
-    }
+  mkdirSync(dirname(defaultPath), { recursive: true, mode: 0o700 });
+  writeFileSync(defaultPath, JSON.stringify(Array.from(keypair.secretKey)) + "\n", { mode: 0o600 });
+
+  if (platform !== "win32") {
     try {
-      const expanded = expandHome(filePath.trim());
-      const keypair = validateKeypairFile(expanded);
-      console.log(`\n  Wallet address: ${keypair.publicKey.toBase58()}`);
-      return { keypair, path: expanded };
+      chmodSync(defaultPath, 0o600);
     } catch (err) {
-      console.log(`  ${err.message}`);
-      if (attempt < MAX_RETRIES - 1) console.log("  Try again.");
+      p.log.warn(`Could not set file permissions: ${err.message}. Run: chmod 600 ${defaultPath}`);
     }
   }
-  throw new Error("Too many invalid attempts. Exiting.");
+
+  p.log.success(`Keypair saved to ${pc.dim(defaultPath)}`);
+  return { publicKey, path: defaultPath };
+}
+
+async function useExistingKeypair() {
+  const filePath = handleCancel(
+    await p.text({
+      message: "Path to keypair file:",
+      placeholder: "~/.config/solana/id.json",
+      validate(value) {
+        if (!value || value.trim().length === 0) return "Path is required.";
+        try {
+          const expanded = expandHome(value.trim());
+          validateKeypairFile(expanded);
+        } catch (err) {
+          return err.message;
+        }
+      },
+    }),
+  );
+
+  const expanded = expandHome(filePath.trim());
+  const keypair = validateKeypairFile(expanded);
+  const publicKey = keypair.publicKey.toBase58();
+
+  p.log.info(`Wallet address: ${pc.cyan(publicKey)}`);
+
+  return { publicKey, path: expanded };
+}
+
+async function setupKeypair() {
+  const method = handleCancel(
+    await p.select({
+      message: "How would you like to set up your Solana keypair?",
+      options: [
+        {
+          value: "phantom",
+          label: "Import from Phantom",
+          hint: "paste your base58 private key",
+        },
+        {
+          value: "existing",
+          label: "Use existing keypair file",
+          hint: "Solana CLI JSON format",
+        },
+      ],
+    }),
+  );
+
+  if (method === "phantom") {
+    return importFromPhantom();
+  } else {
+    return useExistingKeypair();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Step 4: API Key
+// ---------------------------------------------------------------------------
+
+async function setupApiKey() {
+  const apiKey = handleCancel(
+    await p.password({
+      message: "Kinetic API key (optional) (press Enter to skip):",
+      mask: "*",
+    }),
+  );
+
+  return apiKey?.trim() || null;
 }
 
 // ---------------------------------------------------------------------------
-// Claude Desktop config
+// Step 5: Advanced Settings
 // ---------------------------------------------------------------------------
 
-function generateConfigEntry(keypairPath, apiKey) {
+const DEFAULTS = {
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  maxTradeSol: "10",
+  priorityFeeLamports: "400000",
+  jitoEnabled: false,
+  dynamicSlippageMaxBps: "300",
+};
+
+async function advancedSettings() {
+  const configure = handleCancel(
+    await p.confirm({
+      message: "Configure advanced settings?",
+      initialValue: false,
+    }),
+  );
+
+  if (!configure) return {};
+
+  p.log.info(pc.dim("Press Enter to keep defaults shown."));
+
+  const rpcUrl = handleCancel(
+    await p.text({
+      message: "Solana RPC URL:",
+      placeholder: DEFAULTS.rpcUrl,
+      defaultValue: DEFAULTS.rpcUrl,
+      validate(value) {
+        if (!value) return;
+        try {
+          const url = new URL(value);
+          if (url.protocol !== "https:") return "URL must use https://";
+        } catch {
+          return "Invalid URL format.";
+        }
+      },
+    }),
+  );
+
+  const maxTradeSol = handleCancel(
+    await p.text({
+      message: "Max trade size (SOL):",
+      placeholder: DEFAULTS.maxTradeSol,
+      defaultValue: DEFAULTS.maxTradeSol,
+      validate(value) {
+        if (!value) return;
+        const num = Number(value);
+        if (isNaN(num) || num <= 0) return "Must be a positive number.";
+      },
+    }),
+  );
+
+  const priorityFeeLamports = handleCancel(
+    await p.text({
+      message: `Priority fee (lamports): ${pc.dim("400000 = ~0.0004 SOL")}`,
+      placeholder: DEFAULTS.priorityFeeLamports,
+      defaultValue: DEFAULTS.priorityFeeLamports,
+      validate(value) {
+        if (!value) return;
+        const num = Number(value);
+        if (isNaN(num) || !Number.isInteger(num) || num < 0)
+          return "Must be a non-negative integer.";
+      },
+    }),
+  );
+
+  const jitoEnabled = handleCancel(
+    await p.confirm({
+      message: "Enable Jito MEV protection?",
+      initialValue: DEFAULTS.jitoEnabled,
+    }),
+  );
+
+  const dynamicSlippageMaxBps = handleCancel(
+    await p.text({
+      message: "Max dynamic slippage (BPS):",
+      placeholder: DEFAULTS.dynamicSlippageMaxBps,
+      defaultValue: DEFAULTS.dynamicSlippageMaxBps,
+      validate(value) {
+        if (!value) return;
+        const num = Number(value);
+        if (isNaN(num) || !Number.isInteger(num) || num <= 0) return "Must be a positive integer.";
+        if (num > 1000) return "Cannot exceed 1000 BPS (10%).";
+      },
+    }),
+  );
+
+  // Return only non-default values
+  const settings = {};
+  if (rpcUrl !== DEFAULTS.rpcUrl) settings.SOLANA_RPC_URL = rpcUrl;
+  if (maxTradeSol !== DEFAULTS.maxTradeSol) settings.MAX_TRADE_SOL = maxTradeSol;
+  if (priorityFeeLamports !== DEFAULTS.priorityFeeLamports)
+    settings.PRIORITY_FEE_LAMPORTS = priorityFeeLamports;
+  if (jitoEnabled !== DEFAULTS.jitoEnabled) settings.JITO_ENABLED = jitoEnabled ? "true" : "false";
+  if (dynamicSlippageMaxBps !== DEFAULTS.dynamicSlippageMaxBps)
+    settings.DYNAMIC_SLIPPAGE_MAX_BPS = dynamicSlippageMaxBps;
+
+  return settings;
+}
+
+// ---------------------------------------------------------------------------
+// Step 6: Claude Desktop Config
+// ---------------------------------------------------------------------------
+
+function generateConfigEntry(keypairPath, apiKey, advancedEnv) {
   const projectRoot = resolve(".");
   const entry = {
     command: execPath,
@@ -265,55 +442,84 @@ function generateConfigEntry(keypairPath, apiKey) {
   if (apiKey) {
     entry.env.API_KEY = apiKey;
   }
+  // Add non-default advanced settings
+  if (advancedEnv) {
+    Object.assign(entry.env, advancedEnv);
+  }
   return entry;
 }
 
-function printConfigSnippet(entry) {
+function formatConfigSnippet(entry) {
   const snippet = {
     mcpServers: {
       "solana-trading": entry,
     },
   };
-  console.log("\n  Add this to your claude_desktop_config.json:");
-  console.log("");
-  console.log("  " + JSON.stringify(snippet, null, 2).split("\n").join("\n  "));
-  console.log("");
-  console.log("  If you already have other MCP servers configured,");
-  console.log('  merge the "solana-trading" entry into your existing "mcpServers" object.');
+  return JSON.stringify(snippet, null, 2);
 }
 
-async function configureClaudeDesktop(keypairPath, apiKey) {
-  console.log("\n--- Configure Claude Desktop ---");
+async function configureClaudeDesktop(keypairPath, apiKey, advancedEnv) {
+  const entry = generateConfigEntry(keypairPath, apiKey, advancedEnv);
 
   if (isWSL()) {
-    console.log("");
-    console.log("  WSL detected. Claude Desktop runs on the Windows host.");
-    console.log("  Config file is at: %APPDATA%\\Claude\\claude_desktop_config.json");
-    console.log("  (Usually C:\\Users\\<username>\\AppData\\Roaming\\Claude\\claude_desktop_config.json)");
-    console.log("");
-    const entry = generateConfigEntry(keypairPath, apiKey);
-    printConfigSnippet(entry);
+    p.note(
+      [
+        "WSL detected. Claude Desktop runs on the Windows host.",
+        "",
+        `Config file: ${pc.dim("%APPDATA%\\Claude\\claude_desktop_config.json")}`,
+        "",
+        "Add this to your config:",
+        "",
+        formatConfigSnippet(entry),
+        "",
+        pc.dim('Merge "solana-trading" into your existing "mcpServers" object.'),
+      ].join("\n"),
+      "Claude Desktop Config",
+    );
     return;
   }
 
   const configPath = getClaudeConfigPath();
   if (!configPath) {
-    console.log("  Could not detect Claude Desktop config path for this platform.");
-    const entry = generateConfigEntry(keypairPath, apiKey);
-    printConfigSnippet(entry);
+    p.note(
+      [
+        "Could not detect Claude Desktop config path.",
+        "",
+        "Add this to your claude_desktop_config.json:",
+        "",
+        formatConfigSnippet(entry),
+      ].join("\n"),
+      "Claude Desktop Config",
+    );
     return;
   }
 
-  console.log(`  Config file: ${configPath}`);
-  const entry = generateConfigEntry(keypairPath, apiKey);
+  p.log.info(`Config file: ${pc.dim(configPath)}`);
 
-  const autoModify = await askYesNo("\n  Automatically add this MCP server to Claude Desktop config?");
+  const autoModify = handleCancel(
+    await p.confirm({
+      message: "Automatically add this MCP server to Claude Desktop config?",
+      initialValue: true,
+    }),
+  );
 
   if (!autoModify) {
-    printConfigSnippet(entry);
+    p.note(
+      [
+        "Add this to your claude_desktop_config.json:",
+        "",
+        formatConfigSnippet(entry),
+        "",
+        pc.dim('Merge "solana-trading" into your existing "mcpServers" object.'),
+      ].join("\n"),
+      "Manual Config",
+    );
     return;
   }
 
+  const s = p.spinner();
+  s.start("Writing Claude Desktop config...");
+
   // Read existing config
   let config = {};
   if (existsSync(configPath)) {
@@ -321,117 +527,234 @@ async function configureClaudeDesktop(keypairPath, apiKey) {
       const raw = readFileSync(configPath, "utf-8");
       config = JSON.parse(raw);
     } catch {
-      console.log("  Existing config file has invalid JSON. Cannot auto-modify.");
-      printConfigSnippet(entry);
+      s.stop("Existing config has invalid JSON");
+      p.note(
+        [
+          "Could not parse existing config file.",
+          "",
+          "Add this manually to your claude_desktop_config.json:",
+          "",
+          formatConfigSnippet(entry),
+        ].join("\n"),
+        "Manual Config",
+      );
       return;
     }
 
     // Backup
     const backupPath = configPath + ".bak";
     copyFileSync(configPath, backupPath);
-    console.log(`  Backup created: ${backupPath}`);
+    p.log.info(`Backup created: ${pc.dim(backupPath)}`);
   }
 
-  // Merge
-  if (!config.mcpServers) {
-    config.mcpServers = {};
-  }
+  // Check for existing entry
+  if (config.mcpServers?.["solana-trading"]) {
+    s.stop("Existing entry found");
+    const overwrite = handleCancel(
+      await p.confirm({
+        message: "A 'solana-trading' entry already exists. Overwrite?",
+        initialValue: false,
+      }),
+    );
 
-  if (config.mcpServers["solana-trading"]) {
-    const overwrite = await askYesNo("  A 'solana-trading' entry already exists. Overwrite?");
     if (!overwrite) {
-      console.log("  Skipped. Existing config preserved.");
+      p.log.info("Existing config preserved.");
       return;
     }
+
+    s.start("Writing Claude Desktop config...");
   }
 
+  // Merge
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
   config.mcpServers["solana-trading"] = entry;
 
   // Write
   mkdirSync(dirname(configPath), { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  console.log("  Claude Desktop config updated successfully.");
+
+  s.stop("Claude Desktop config updated");
 }
 
 // ---------------------------------------------------------------------------
-// Main wizard
+// Step 7: Verification
 // ---------------------------------------------------------------------------
 
-async function main() {
-  console.log("");
-  console.log("  Solana Trading MCP Server — Setup Wizard");
-  console.log("  =========================================");
-  console.log("");
+const MAX_VERIFICATION_RETRIES = 3;
 
-  // Step 1: Check build
-  const buildExists = existsSync(resolve("build", "index.js"));
-  if (!buildExists) {
-    console.log("  The project hasn't been built yet (build/index.js not found).");
-    const runBuild = await askYesNo("  Run 'npm run build' now?");
-    if (runBuild) {
-      console.log("  Building...");
+async function runVerification(keypairPath, rpcUrl, apiKey) {
+  for (let attempt = 0; attempt <= MAX_VERIFICATION_RETRIES; attempt++) {
+    const s = p.spinner();
+    let hasFailure = false;
+
+    // 1. Load keypair
+    s.start("Loading keypair...");
+    let keypair;
+    try {
+      keypair = validateKeypairFile(keypairPath);
+      s.stop(`Keypair loaded — ${pc.cyan(keypair.publicKey.toBase58())}`);
+    } catch (err) {
+      s.stop(`Keypair load failed: ${err.message}`);
+      hasFailure = true;
+    }
+
+    // 2. Check SOL balance (only if keypair loaded)
+    if (keypair) {
+      const effectiveRpc = rpcUrl || DEFAULTS.rpcUrl;
+      s.start("Checking SOL balance...");
       try {
-        execSync("npm run build", { stdio: "inherit" });
-        console.log("  Build complete.");
-      } catch {
-        console.log("  Build failed. You can try again later with: npm run build");
-        console.log("  Continuing setup anyway...");
+        const response = await fetch(effectiveRpc, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "getBalance",
+            params: [keypair.publicKey.toBase58()],
+          }),
+          signal: AbortSignal.timeout(10_000),
+        });
+
+        const data = await response.json();
+        const lamports = data.result?.value ?? 0;
+        const sol = (lamports / 1e9).toFixed(4);
+
+        if (lamports === 0) {
+          s.stop(`Balance: ${pc.yellow("0 SOL")}`);
+          p.log.warn("Fund this wallet with SOL before trading.");
+        } else {
+          s.stop(`Balance: ${pc.green(sol + " SOL")}`);
+        }
+      } catch (err) {
+        const msg =
+          err.name === "TimeoutError" || err.name === "AbortError"
+            ? "Request timed out"
+            : err.message;
+        s.stop(`Balance check failed: ${pc.yellow(msg)}`);
+        hasFailure = true;
+      }
+    }
+
+    // 3. Test Kinetic API (only if API key provided)
+    if (apiKey) {
+      s.start("Testing Kinetic API...");
+      try {
+        const response = await fetch("https://auth.kinetic.xyz/v1/token", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ apiKey }),
+          signal: AbortSignal.timeout(10_000),
+        });
+
+        if (response.ok) {
+          s.stop(`Kinetic API: ${pc.green("connected")}`);
+        } else {
+          s.stop(`Kinetic API: ${pc.yellow(`${response.status} ${response.statusText}`)}`);
+          hasFailure = true;
+        }
+      } catch (err) {
+        const msg =
+          err.name === "TimeoutError" || err.name === "AbortError"
+            ? "Request timed out"
+            : err.message;
+        s.stop(`Kinetic API: ${pc.yellow(msg)}`);
+        hasFailure = true;
+      }
+    } else {
+      p.log.info(pc.dim("Skipping Kinetic API test (no API key)."));
+    }
+
+    if (!hasFailure) return;
+
+    // Retry on failure (up to MAX_VERIFICATION_RETRIES)
+    if (attempt < MAX_VERIFICATION_RETRIES) {
+      const retry = handleCancel(
+        await p.confirm({
+          message: "Some checks failed. Retry verification?",
+          initialValue: true,
+        }),
+      );
+
+      if (!retry) {
+        p.log.warn("Continuing with warnings. You can verify connectivity later.");
+        return;
       }
     } else {
-      console.log("  Skipped. Remember to run 'npm run build' before using the server.");
+      p.log.warn("Maximum retries reached. Continuing with warnings.");
+      return;
     }
   }
+}
 
-  // Step 2: Keypair setup
-  const choice = await askChoice("How would you like to set up your Solana keypair?", [
-    "Import private key from Phantom (or another wallet)",
-    "Use an existing Solana CLI keypair file",
-  ]);
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
 
-  let keypairResult;
-  if (choice === 1) {
-    keypairResult = await importFromPhantom();
-  } else {
-    keypairResult = await useExistingKeypair();
+async function main() {
+  await renderBanner();
+  p.intro(pc.bold("Setup Wizard"));
+
+  // Step 2: Build check
+  await checkBuild();
+
+  // Step 3: Keypair setup
+  const keypairResult = await setupKeypair();
+
+  // Step 4: API key
+  const apiKey = await setupApiKey();
+
+  // Step 5: Advanced settings
+  const advancedEnv = await advancedSettings();
+
+  // Step 6: Claude Desktop config
+  await configureClaudeDesktop(keypairResult.path, apiKey, advancedEnv);
+
+  // Step 7: Verification
+  const rpcUrl = advancedEnv.SOLANA_RPC_URL || null;
+  await runVerification(keypairResult.path, rpcUrl, apiKey);
+
+  // Step 8: Outro
+  const summaryLines = [
+    `Wallet:  ${pc.cyan(keypairResult.publicKey)}`,
+    `Keypair: ${pc.dim(keypairResult.path)}`,
+  ];
+  if (apiKey) summaryLines.push(`API Key: ${pc.green("configured")}`);
+
+  const advancedKeys = Object.keys(advancedEnv);
+  if (advancedKeys.length > 0) {
+    summaryLines.push("");
+    summaryLines.push(pc.bold("Custom settings:"));
+    for (const [key, val] of Object.entries(advancedEnv)) {
+      summaryLines.push(`  ${pc.dim(key)}: ${val}`);
+    }
   }
 
-  // Step 3: Optional API key
-  console.log("\n--- API Key (Optional) ---");
-  console.log("  A Kinetic API key gives you higher rate limits.");
-  const apiKeyInput = await rl.question("  API Key (press Enter to skip): ");
-  const apiKey = apiKeyInput.trim() || null;
-
-  // Step 4: Claude Desktop config
-  await configureClaudeDesktop(keypairResult.path, apiKey);
-
-  // Step 5: Success summary
-  console.log("");
-  console.log("  Setup Complete!");
-  console.log("  ===============");
-  console.log(`  Wallet: ${keypairResult.keypair.publicKey.toBase58()}`);
-  console.log(`  Keypair: ${keypairResult.path}`);
-  if (apiKey) console.log("  API Key: configured");
-  console.log("");
-  console.log("  Next steps:");
-  console.log("  1. Restart Claude Desktop (fully quit and reopen)");
-  console.log('  2. Look for the hammer icon in the chat input');
-  console.log('  3. Try: "What\'s my SOL balance?"');
-  console.log("");
-  console.log("  Safety guardrails:");
-  console.log("  - Swaps always show a preview first (confirm=false)");
-  console.log("  - Max trade size: 10 SOL (configurable via MAX_TRADE_SOL)");
-  console.log("  - Slippage capped at 10% (1000 bps)");
-  console.log("");
-
-  rl.close();
+  p.note(summaryLines.join("\n"), "Setup Complete");
+
+  p.note(
+    [
+      `1. ${pc.bold("Restart Claude Desktop")} (fully quit and reopen)`,
+      `2. Look for the ${pc.bold("hammer icon")} in the chat input`,
+      `3. Try: ${pc.cyan('"What\'s my SOL balance?"')}`,
+      "",
+      pc.dim("Safety guardrails:"),
+      pc.dim(`  • Swaps always show a preview first`),
+      pc.dim(`  • Max trade size: ${advancedEnv.MAX_TRADE_SOL || "10"} SOL`),
+      pc.dim(`  • Slippage capped at ${advancedEnv.DYNAMIC_SLIPPAGE_MAX_BPS || "300"} BPS`),
+    ].join("\n"),
+    "Next Steps",
+  );
+
+  p.outro(pc.green("You're all set! Happy trading."));
 }
 
 main().catch((err) => {
   if (err.message === "Cancelled by user") {
-    console.log("\n  Setup cancelled.");
+    p.cancel("Setup cancelled.");
   } else {
-    console.error(`\n  Setup failed: ${err.message}`);
+    p.log.error(`Setup failed: ${err.message}`);
   }
-  rl.close();
   process.exit(1);
 });