@tostudy-ai/mcp-setup 1.3.0 → 1.4.0

package/dist/index.js

@@ -1,664 +1,3034 @@
-#!/usr/bin/env node
-/**
- * ToStudy MCP Setup CLI
- *
- * Configures Claude Code to connect to the ToStudy MCP server.
- *
- * Usage:
- *   npx @tostudy-ai/mcp-setup
- *   npx @tostudy-ai/mcp-setup wizard
- *   npx @tostudy-ai/mcp-setup --api-key <key>
- *   npx @tostudy-ai/mcp-setup --uninstall
- */
+// src/index.ts
 import { program } from "commander";
-import chalk from "chalk";
-import { execFile } from "node:child_process";
-import { getClaudeConfigPath, isClaudeInstalled, addTostudyMcpServer, removeTostudyMcpServer, isTostudyMcpConfigured, } from "./config.js";
-import { promptApiKey, confirm, prompt } from "./prompts.js";
-import { getInstalledIDEs } from "./detect.js";
-import { runDiagnostics, printDiagnosticReport } from "./diagnose.js";
-import { repairAllIssues, printRepairReport } from "./repair.js";
-import { getIDEHandler, detectInstalledIDEs } from "./ide-handlers/index.js";
-import { startCallbackServer } from "./oauth-server.js";
-const VERSION = "1.3.0";
-const DEFAULT_PLATFORM_URL = "https://tostudy.ai";
-const OAUTH_PORT = 9877;
+import chalk6 from "chalk";
+import { execFile } from "child_process";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir, platform } from "os";
+function extractApiKey(config) {
+  const authHeader = config.headers?.["Authorization"];
+  if (authHeader?.startsWith("Bearer ")) {
+    return authHeader.replace("Bearer ", "");
+  }
+  if (config.args) {
+    for (let i = 0; i < config.args.length; i++) {
+      if (config.args[i] === "--header" && config.args[i + 1]?.startsWith("Authorization:Bearer ")) {
+        return config.args[i + 1].replace("Authorization:Bearer ", "");
+      }
+    }
+  }
+  return null;
+}
+function extractMcpUrl(config) {
+  if (config.url) {
+    return config.url;
+  }
+  if (config.args && config.args[0] === "-y" && config.args[1] === "mcp-remote" && config.args[2]) {
+    return config.args[2];
+  }
+  return null;
+}
+function getClientOsHeaderValue() {
+  switch (platform()) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return "linux";
+  }
+}
+function getClaudeConfigPath() {
+  const home = homedir();
+  const os = platform();
+  switch (os) {
+    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"
+      );
+    case "linux":
+      return join(home, ".config", "Claude", "claude_desktop_config.json");
+    default:
+      throw new Error(`Unsupported operating system: ${os}`);
+  }
+}
+function isClaudeInstalled() {
+  const configPath = getClaudeConfigPath();
+  const configDir = dirname(configPath);
+  return existsSync(configDir);
+}
+function readClaudeConfig() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync(configPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function writeClaudeConfig(config) {
+  const configPath = getClaudeConfigPath();
+  const configDir = dirname(configPath);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  if (existsSync(configPath)) {
+    const backupPath = `${configPath}.backup`;
+    copyFileSync(configPath, backupPath);
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function addTostudyMcpServer(apiKey, platformUrl, clientInfo = {}) {
+  const config = readClaudeConfig();
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  const ide = clientInfo.ide || "desktop";
+  const os = clientInfo.os || getClientOsHeaderValue();
+  config.mcpServers["tostudy"] = {
+    command: "npx",
+    args: [
+      "-y",
+      "mcp-remote",
+      `${platformUrl}/mcp`,
+      "--header",
+      `Authorization:Bearer ${apiKey}`,
+      "--header",
+      `X-Tostudy-Client-IDE:${ide}`,
+      "--header",
+      `X-Tostudy-Client-OS:${os}`
+    ]
+  };
+  writeClaudeConfig(config);
+}
+function removeTostudyMcpServer() {
+  const config = readClaudeConfig();
+  if (config.mcpServers && config.mcpServers["tostudy"]) {
+    delete config.mcpServers["tostudy"];
+    writeClaudeConfig(config);
+  }
+}
+function isTostudyMcpConfigured() {
+  const config = readClaudeConfig();
+  return !!(config.mcpServers && config.mcpServers["tostudy"]);
+}
+function getTostudyMcpConfig() {
+  const config = readClaudeConfig();
+  return config.mcpServers?.["tostudy"] || null;
+}
+
+// src/prompts.ts
+import * as readline from "readline";
 function println(message = "") {
-    process.stdout.write(`${message}\n`);
+  process.stdout.write(`${message}
+`);
 }
-function eprintln(message = "") {
-    process.stderr.write(`${message}\n`);
+function createInterface2() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
 }
-/**
- * Print styled banner
- */
-function printBanner() {
-    println();
-    println(chalk.cyan("  ╔═══════════════════════════════════════╗"));
-    println(chalk.cyan("  ║") + chalk.white.bold("   ToStudy MCP Setup              ") + chalk.cyan("║"));
-    println(chalk.cyan("  ╚═══════════════════════════════════════╝"));
-    println();
-}
-/**
- * Validate API key with the platform
- */
-async function validateApiKey(apiKey, platformUrl) {
-    try {
-        const response = await fetch(`${platformUrl}/api/mcp/heartbeat`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ timestamp: new Date().toISOString() }),
-        });
-        return response.ok || response.status === 204;
-    }
-    catch {
-        // Network error - can't validate, but allow anyway for offline setup
-        println(chalk.yellow("! Nao foi possivel validar a API key (servidor offline?)"));
-        println(chalk.yellow("  A configuracao sera salva mesmo assim."));
-        return true;
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface2();
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function promptApiKey() {
+  println();
+  println("Cole sua API key (de /student/settings/mcp):");
+  const apiKey = await prompt("> ");
+  if (!apiKey) {
+    throw new Error("API key n\xE3o pode ser vazia");
+  }
+  if (apiKey.length < 32) {
+    throw new Error("API key parece ser muito curta. Verifique e tente novamente.");
+  }
+  return apiKey;
+}
+async function confirm(question, defaultValue = false) {
+  const defaultStr = defaultValue ? "[S/n]" : "[s/N]";
+  const answer = await prompt(`${question} ${defaultStr} `);
+  if (!answer) {
+    return defaultValue;
+  }
+  return answer.toLowerCase().startsWith("s") || answer.toLowerCase().startsWith("y");
+}
+async function promptCourseSelection(courses) {
+  if (courses.length === 0) {
+    return null;
+  }
+  println();
+  println("Cursos ativos:");
+  courses.forEach((course, index2) => {
+    println(`  ${index2 + 1}. ${course.title} \u2014 ${course.progressPercent}% completo`);
+  });
+  const answer = await prompt(`Selecione um curso [1-${courses.length}] (default: 1): `);
+  if (!answer) {
+    return courses[0]?.id ?? null;
+  }
+  const index = Number.parseInt(answer, 10);
+  if (!Number.isInteger(index) || index < 1 || index > courses.length) {
+    println("Sele\xE7\xE3o inv\xE1lida.");
+    return null;
+  }
+  return courses[index - 1]?.id ?? null;
+}
+
+// src/detect.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2, platform as platform2 } from "os";
+function getVSCodeConfigDir(variant) {
+  const home = homedir2();
+  const os = platform2();
+  const folderNames = {
+    stable: "Code",
+    insiders: "Code - Insiders",
+    cursor: "Cursor"
+  };
+  const folder = folderNames[variant];
+  switch (os) {
+    case "darwin":
+      return join2(home, "Library", "Application Support", folder, "User");
+    case "win32":
+      return join2(process.env.APPDATA || join2(home, "AppData", "Roaming"), folder, "User");
+    case "linux":
+      return join2(home, ".config", folder, "User");
+    default:
+      return "";
+  }
+}
+function getVSCodeMcpConfigPath(variant) {
+  const configDir = getVSCodeConfigDir(variant);
+  if (!configDir) return "";
+  return join2(configDir, "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json");
+}
+function isVSCodeInstalled(variant) {
+  const os = platform2();
+  const home = homedir2();
+  const appNames = {
+    stable: ["Visual Studio Code.app", "code"],
+    insiders: ["Visual Studio Code - Insiders.app", "code-insiders"],
+    cursor: ["Cursor.app", "cursor"]
+  };
+  const [macApp, linuxCmd] = appNames[variant];
+  switch (os) {
+    case "darwin":
+      return existsSync2(join2("/Applications", macApp)) || existsSync2(join2(home, "Applications", macApp));
+    case "win32": {
+      const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+      const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+      const localAppData = process.env.LOCALAPPDATA || join2(home, "AppData", "Local");
+      const winPaths = variant === "cursor" ? [join2(localAppData, "Programs", "cursor", "Cursor.exe")] : [
+        join2(programFiles, "Microsoft VS Code", "Code.exe"),
+        join2(programFilesX86, "Microsoft VS Code", "Code.exe"),
+        join2(localAppData, "Programs", "Microsoft VS Code", "Code.exe")
+      ];
+      if (variant === "insiders") {
+        winPaths.push(
+          join2(programFiles, "Microsoft VS Code Insiders", "Code - Insiders.exe"),
+          join2(localAppData, "Programs", "Microsoft VS Code Insiders", "Code - Insiders.exe")
+        );
+      }
+      return winPaths.some((p) => existsSync2(p));
     }
+    case "linux":
+      return existsSync2(getVSCodeConfigDir(variant)) || existsSync2(join2("/usr/bin", linuxCmd)) || existsSync2(join2("/usr/local/bin", linuxCmd)) || existsSync2(join2(home, ".local", "bin", linuxCmd));
+    default:
+      return false;
+  }
 }
-/**
- * Exchange an OAuth authorization code for a JWT token.
- */
-async function exchangeCodeForToken(code, platformUrl, client = "mcp") {
-    const res = await fetch(`${platformUrl}/api/cli/auth/exchange`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ code, client }),
+function getJetBrainsConfigDir() {
+  const home = homedir2();
+  const os = platform2();
+  switch (os) {
+    case "darwin":
+      return join2(home, "Library", "Application Support", "JetBrains");
+    case "win32":
+      return join2(process.env.APPDATA || join2(home, "AppData", "Roaming"), "JetBrains");
+    case "linux":
+      return join2(home, ".config", "JetBrains");
+    default:
+      return "";
+  }
+}
+function getInstalledJetBrainsIDEs() {
+  const configDir = getJetBrainsConfigDir();
+  if (!configDir || !existsSync2(configDir)) {
+    return [];
+  }
+  try {
+    const entries = readdirSync(configDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => {
+      return /^(IntelliJIdea|WebStorm|PyCharm|PhpStorm|GoLand|Rider|CLion|RubyMine|DataGrip|Fleet)\d{4}\.\d/i.test(name);
     });
-    if (!res.ok) {
-        const body = (await res.json().catch(() => ({})));
-        throw new Error(body.error ?? `Falha na autenticacao (${res.status})`);
+  } catch {
+    return [];
+  }
+}
+function isJetBrainsInstalled() {
+  const installedIDEs = getInstalledJetBrainsIDEs();
+  return installedIDEs.length > 0;
+}
+function getPrimaryJetBrainsIDE() {
+  const installedIDEs = getInstalledJetBrainsIDEs();
+  if (installedIDEs.length === 0) return null;
+  const sorted = installedIDEs.sort((a, b) => {
+    const versionA = a.match(/\d{4}\.\d/)?.[0] || "0";
+    const versionB = b.match(/\d{4}\.\d/)?.[0] || "0";
+    return versionB.localeCompare(versionA);
+  });
+  return sorted[0];
+}
+function getJetBrainsMcpConfigPath(ideDir) {
+  const configDir = getJetBrainsConfigDir();
+  if (!configDir) return "";
+  const targetDir = ideDir || getPrimaryJetBrainsIDE();
+  if (!targetDir) return "";
+  return join2(configDir, targetDir, "options", "mcp-servers.json");
+}
+function detectVSCode() {
+  const installed = isVSCodeInstalled("stable");
+  return {
+    type: "vscode",
+    name: "Visual Studio Code",
+    configPath: getVSCodeMcpConfigPath("stable"),
+    installed
+  };
+}
+function detectVSCodeInsiders() {
+  const installed = isVSCodeInstalled("insiders");
+  return {
+    type: "vscode-insiders",
+    name: "Visual Studio Code - Insiders",
+    configPath: getVSCodeMcpConfigPath("insiders"),
+    installed
+  };
+}
+function detectCursor() {
+  const installed = isVSCodeInstalled("cursor");
+  return {
+    type: "cursor",
+    name: "Cursor",
+    configPath: getVSCodeMcpConfigPath("cursor"),
+    installed
+  };
+}
+function detectJetBrains() {
+  const installed = isJetBrainsInstalled();
+  const primaryIDE = getPrimaryJetBrainsIDE();
+  let name = "JetBrains IDE";
+  let version;
+  if (primaryIDE) {
+    const match = primaryIDE.match(/^(\w+?)(\d{4}\.\d)/);
+    if (match) {
+      const ideNames = {
+        "IntelliJIdea": "IntelliJ IDEA",
+        "WebStorm": "WebStorm",
+        "PyCharm": "PyCharm",
+        "PhpStorm": "PhpStorm",
+        "GoLand": "GoLand",
+        "Rider": "Rider",
+        "CLion": "CLion",
+        "RubyMine": "RubyMine",
+        "DataGrip": "DataGrip",
+        "Fleet": "Fleet"
+      };
+      name = ideNames[match[1]] || match[1];
+      version = match[2];
     }
-    return res.json();
+  }
+  return {
+    type: "jetbrains",
+    name,
+    version,
+    configPath: getJetBrainsMcpConfigPath(),
+    installed
+  };
 }
-/**
- * Detect IDEs, let user choose which to configure, then write config.
- */
-async function configureIDEs(token, platformUrl) {
-    const mcpUrl = resolveMcpServerUrl(platformUrl);
-    // Exclude "manual" from auto-detection (it prints JWT to screen)
-    const allDetected = await detectInstalledIDEs();
-    const installedIDEs = allDetected.filter((h) => h.id !== "manual");
-    if (installedIDEs.length === 0) {
-        println(chalk.yellow("  Nenhuma IDE suportada detectada."));
-        println(chalk.gray("  Use: npx @tostudy-ai/mcp-setup install --ide <nome> --key <token>"));
-        return 0;
-    }
-    // Show detected IDEs and let user choose
-    println(chalk.white("  IDEs detectadas:\n"));
-    for (let i = 0; i < installedIDEs.length; i++) {
-        println(`    ${chalk.cyan(String(i + 1))}. ${installedIDEs[i].name}`);
-    }
-    println(`    ${chalk.cyan("a")}. Todas`);
-    println();
-    const answer = await prompt("  Quais configurar? (números separados por vírgula, ou 'a' para todas) ");
-    const trimmed = answer.trim().toLowerCase();
-    let selectedIDEs;
-    if (!trimmed || trimmed === "a" || trimmed === "all") {
-        selectedIDEs = installedIDEs;
-    }
-    else {
-        const indices = trimmed
-            .split(/[,\s]+/)
-            .map((s) => parseInt(s, 10) - 1)
-            .filter((i) => i >= 0 && i < installedIDEs.length);
-        if (indices.length === 0) {
-            println(chalk.yellow("  Nenhuma IDE selecionada."));
-            return 0;
-        }
-        selectedIDEs = indices.map((i) => installedIDEs[i]);
-    }
-    println();
-    // For Claude Code, ask global vs local
-    const claudeCodeHandler = selectedIDEs.find((h) => h.id === "claude-code");
-    let claudeCodeScope = "user";
-    if (claudeCodeHandler) {
-        const scopeAnswer = await prompt("  Claude Code: configurar global ou local? (g/l, default: global) ");
-        claudeCodeScope = scopeAnswer.trim().toLowerCase().startsWith("l") ? "project" : "user";
-        println();
-    }
-    let configured = 0;
-    for (const handler of selectedIDEs) {
-        process.stdout.write(`  ${chalk.gray("Configurando")} ${handler.name}... `);
-        try {
-            if (handler.id === "claude-code") {
-                await writeClaudeCodeConfig(handler, token, mcpUrl, claudeCodeScope);
-            }
-            else {
-                await handler.writeConfig(token, mcpUrl);
-            }
-            println(chalk.green("OK"));
-            configured++;
-        }
-        catch (error) {
-            println(chalk.red("FALHOU"));
-            eprintln(chalk.gray(`    ${error instanceof Error ? error.message : String(error)}`));
-        }
+function detectAllIDEs() {
+  return [
+    detectVSCode(),
+    detectVSCodeInsiders(),
+    detectCursor(),
+    detectJetBrains()
+  ];
+}
+function getInstalledIDEs() {
+  return detectAllIDEs().filter((ide) => ide.installed);
+}
+if (process.argv[1]?.endsWith("detect.js")) {
+  const installedIDEs = getInstalledIDEs();
+  if (installedIDEs.length === 0) {
+    process.stdout.write("No supported IDEs detected.\n");
+    process.stdout.write("\nSupported IDEs:\n");
+    process.stdout.write("  - Visual Studio Code\n");
+    process.stdout.write("  - Visual Studio Code - Insiders\n");
+    process.stdout.write("  - Cursor\n");
+    process.stdout.write("  - JetBrains IDEs (IntelliJ, WebStorm, PyCharm, etc.)\n");
+  } else {
+    process.stdout.write("Detected IDEs:\n");
+    for (const ide of installedIDEs) {
+      const versionStr = ide.version ? ` (${ide.version})` : "";
+      process.stdout.write(`  \u2713 ${ide.name}${versionStr}
+`);
+      process.stdout.write(`    Config: ${ide.configPath || "N/A"}
+`);
     }
-    return configured;
+  }
+  process.stdout.write("\n--- JSON Output ---\n");
+  process.stdout.write(JSON.stringify(installedIDEs, null, 2) + "\n");
 }
-/**
- * Write Claude Code config with explicit scope (global or project-local).
- */
-async function writeClaudeCodeConfig(handler, token, mcpUrl, scope) {
-    const { execFileSync } = await import("node:child_process");
-    const { buildMcpRemoteArgs } = await import("./ide-handlers/base.js");
-    const args = buildMcpRemoteArgs(token, mcpUrl, "claude-code");
-    try {
-        execFileSync("claude", ["mcp", "remove", "tostudy", "--scope", scope], { stdio: "ignore" });
+
+// src/diagnose.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
+import { createServer } from "net";
+import chalk from "chalk";
+var DEFAULT_MCP_PORT = 3701;
+function println2(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function checkClaudeInstallation() {
+  if (!isClaudeInstalled()) {
+    return {
+      id: "claude-not-installed",
+      severity: "critical",
+      title: "Claude Code nao encontrado",
+      description: "O diretorio de configuracao do Claude Code nao foi encontrado no sistema.",
+      suggestion: "Instale o Claude Code em https://claude.ai/download",
+      autoFixable: false
+    };
+  }
+  return null;
+}
+function checkConfigFile() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync3(configPath)) {
+    return {
+      id: "config-missing",
+      severity: "warning",
+      title: "Arquivo de configuracao nao existe",
+      description: `O arquivo ${configPath} nao foi encontrado. Sera criado durante o setup.`,
+      suggestion: "Execute o comando de setup para criar a configuracao.",
+      autoFixable: true
+    };
+  }
+  try {
+    const stats = statSync(configPath);
+    if (!stats.isFile()) {
+      return {
+        id: "config-not-file",
+        severity: "critical",
+        title: "Configuracao nao e um arquivo",
+        description: `${configPath} existe mas nao e um arquivo valido.`,
+        suggestion: "Remova o item e execute o setup novamente.",
+        autoFixable: false
+      };
+    }
+  } catch {
+    return {
+      id: "config-unreadable",
+      severity: "critical",
+      title: "Arquivo de configuracao inacessivel",
+      description: `Nao foi possivel acessar ${configPath}. Verifique as permissoes.`,
+      suggestion: "Verifique as permissoes do arquivo ou recrie-o.",
+      autoFixable: false
+    };
+  }
+  return null;
+}
+function checkConfigJson() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync3(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    JSON.parse(content);
+  } catch {
+    return {
+      id: "config-invalid-json",
+      severity: "critical",
+      title: "JSON de configuracao invalido",
+      description: "O arquivo de configuracao contem JSON invalido.",
+      suggestion: 'Execute "mcp-setup repair" para corrigir ou remova o arquivo e execute o setup novamente.',
+      autoFixable: true
+    };
+  }
+  return null;
+}
+function checkMcpConfiguration() {
+  if (!isTostudyMcpConfigured()) {
+    return {
+      id: "mcp-not-configured",
+      severity: "warning",
+      title: "ToStudy MCP nao configurado",
+      description: "O servidor MCP da ToStudy nao esta configurado no Claude Code.",
+      suggestion: "Execute o comando de setup para configurar o MCP.",
+      autoFixable: true
+    };
+  }
+  return null;
+}
+function checkApiKeyFormat() {
+  const mcpConfig = getTostudyMcpConfig();
+  if (!mcpConfig) {
+    return null;
+  }
+  const apiKey = extractApiKey(mcpConfig);
+  if (!apiKey) {
+    return {
+      id: "api-key-missing",
+      severity: "critical",
+      title: "API key nao configurada",
+      description: "A configuracao do MCP nao possui uma API key.",
+      suggestion: "Execute o setup novamente com uma API key valida.",
+      autoFixable: true
+    };
+  }
+  if (apiKey.length < 32) {
+    return {
+      id: "api-key-too-short",
+      severity: "warning",
+      title: "API key parece ser muito curta",
+      description: `A API key tem apenas ${apiKey.length} caracteres. API keys validas geralmente tem 32+ caracteres.`,
+      suggestion: "Verifique se copiou a API key completa de /student/settings/mcp.",
+      autoFixable: true
+    };
+  }
+  return null;
+}
+function checkServerUrl() {
+  const mcpConfig = getTostudyMcpConfig();
+  if (!mcpConfig) {
+    return null;
+  }
+  const url = extractMcpUrl(mcpConfig);
+  if (!url) {
+    return {
+      id: "server-url-missing",
+      severity: "critical",
+      title: "URL do servidor MCP nao configurada",
+      description: "A configuracao do MCP nao possui uma URL de servidor.",
+      suggestion: "Execute o setup novamente para configurar a URL correta.",
+      autoFixable: true
+    };
+  }
+  try {
+    const parsedUrl = new URL(url);
+    if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+      return {
+        id: "server-url-invalid-protocol",
+        severity: "critical",
+        title: "Protocolo de URL invalido",
+        description: `O protocolo "${parsedUrl.protocol}" nao e suportado. Use http: ou https:.`,
+        suggestion: "Execute o setup novamente com a URL correta.",
+        autoFixable: true
+      };
     }
-    catch {
-        /* may not exist */
+    const validPaths = ["/mcp/sse", "/mcp"];
+    if (!validPaths.some((p) => parsedUrl.pathname.endsWith(p))) {
+      return {
+        id: "server-url-missing-sse-path",
+        severity: "warning",
+        title: "URL do servidor pode estar incorreta",
+        description: `A URL ${url} nao termina com /mcp como esperado.`,
+        suggestion: "Verifique se a URL esta correta ou execute o setup novamente.",
+        autoFixable: true
+      };
     }
-    execFileSync("claude", ["mcp", "add", "tostudy", "--scope", scope, "--", "npx", ...args], {
-        stdio: "inherit",
+  } catch {
+    return {
+      id: "server-url-invalid",
+      severity: "critical",
+      title: "URL do servidor invalida",
+      description: `A URL "${url}" nao e uma URL valida.`,
+      suggestion: "Execute o setup novamente com uma URL valida.",
+      autoFixable: true
+    };
+  }
+  return null;
+}
+async function checkPortConflict() {
+  const isAvailable = await isPortAvailable(DEFAULT_MCP_PORT);
+  if (!isAvailable) {
+    return {
+      id: "port-conflict",
+      severity: "warning",
+      title: `Porta ${DEFAULT_MCP_PORT} em uso`,
+      description: `A porta padrao do MCP server (${DEFAULT_MCP_PORT}) esta sendo usada por outro processo.`,
+      suggestion: "Verifique qual processo esta usando a porta ou use uma porta alternativa.",
+      autoFixable: false
+    };
+  }
+  return null;
+}
+async function checkServerConnectivity() {
+  const mcpConfig = getTostudyMcpConfig();
+  if (!mcpConfig) {
+    return null;
+  }
+  const mcpUrl = extractMcpUrl(mcpConfig);
+  const apiKey = extractApiKey(mcpConfig);
+  if (!mcpUrl) {
+    return null;
+  }
+  const baseUrl = mcpUrl.replace(/\/mcp(\/sse)?$/, "");
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${baseUrl}/api/mcp/heartbeat`, {
+      method: "POST",
+      headers: {
+        Authorization: apiKey ? `Bearer ${apiKey}` : "",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
+      signal: controller.signal
     });
+    clearTimeout(timeout);
+    if (response.status === 401 || response.status === 403) {
+      return {
+        id: "auth-failed",
+        severity: "critical",
+        title: "Falha de autenticacao",
+        description: "O servidor MCP rejeitou a API key. Ela pode estar expirada ou invalida.",
+        suggestion: "Gere uma nova API key em /student/settings/mcp e execute o setup novamente.",
+        autoFixable: true
+      };
+    }
+    if (!response.ok && response.status !== 204) {
+      return {
+        id: "server-error",
+        severity: "warning",
+        title: `Servidor retornou erro ${response.status}`,
+        description: `O servidor MCP retornou um status de erro: ${response.status}.`,
+        suggestion: "O servidor pode estar temporariamente indisponivel. Tente novamente mais tarde.",
+        autoFixable: false
+      };
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return {
+        id: "server-timeout",
+        severity: "warning",
+        title: "Timeout de conexao",
+        description: "O servidor MCP nao respondeu em 5 segundos.",
+        suggestion: "Verifique sua conexao de internet ou se o servidor esta online.",
+        autoFixable: false
+      };
+    }
+    return {
+      id: "server-unreachable",
+      severity: "warning",
+      title: "Servidor MCP inacessivel",
+      description: "Nao foi possivel conectar ao servidor MCP.",
+      suggestion: "Verifique sua conexao de internet ou se a URL do servidor esta correta.",
+      autoFixable: false
+    };
+  }
+  return null;
 }
-/**
- * Print success banner after IDE configuration.
- */
-function printSuccessBanner(configuredCount) {
-    println();
-    if (configuredCount > 0) {
-        println(chalk.green("  ╔═══════════════════════════════════════════════╗"));
-        println(chalk.green("  ║") +
-            chalk.white.bold(`   ${configuredCount} IDE${configuredCount > 1 ? "s" : ""} configurada${configuredCount > 1 ? "s" : ""} com sucesso!`.padEnd(42)) +
-            chalk.green("║"));
-        println(chalk.green("  ╚═══════════════════════════════════════════════╝"));
-    }
-    else {
-        println(chalk.yellow("  Nenhuma IDE foi configurada."));
-        println(chalk.gray("  Use: npx @tostudy-ai/mcp-setup install --ide <nome> --key <token>"));
-    }
-    println();
-    println(chalk.white("  Próximos passos:"));
-    println(chalk.gray("    1.") + " Reinicie as IDEs configuradas");
-    println(chalk.gray("    2.") + " Peça ao assistente: " + chalk.cyan('"mostre meus cursos"'));
-    println();
-    println(chalk.gray("  ─────────────────────────────────────────"));
-    println();
-    println(chalk.white("  Prefere estudar pelo terminal?"));
-    println(chalk.gray("    ") + chalk.cyan("npm install -g @tostudy-ai/cli"));
-    println(chalk.gray("    ") +
-        chalk.cyan("tostudy login") +
-        chalk.gray(" → ") +
-        chalk.cyan("tostudy courses"));
-    println();
-}
-/**
- * Main setup flow
- */
-async function setup(apiKey, platformUrl) {
-    printBanner();
-    const url = platformUrl || process.env.TOSTUDY_PLATFORM_URL || DEFAULT_PLATFORM_URL;
-    // API key fallback: skip OAuth, use key directly
-    if (apiKey || process.env.TOSTUDY_API_KEY) {
-        const key = apiKey || process.env.TOSTUDY_API_KEY;
-        println(chalk.gray("  Usando API key fornecida..."));
-        process.stdout.write(chalk.gray("  Validando... "));
-        const valid = await validateApiKey(key, url);
-        if (!valid) {
-            println(chalk.red("FALHOU"));
-            println(chalk.red("  API key invalida ou expirada."));
-            process.exit(1);
-        }
-        println(chalk.green("OK"));
-        println();
-        const configured = await configureIDEs(key, url);
-        printSuccessBanner(configured);
-        return;
-    }
-    // OAuth flow
-    println(chalk.gray("  Abrindo browser para autenticacao...\n"));
-    let code;
-    try {
-        const serverPromise = startCallbackServer(OAUTH_PORT);
-        const authUrl = `${url}/api/cli/auth/authorize?port=${OAUTH_PORT}`;
-        const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-        const openArgs = process.platform === "win32" ? ["", authUrl] : [authUrl];
-        execFile(openCmd, openArgs, (err) => {
-            if (err) {
-                println(chalk.yellow("  Não foi possível abrir o browser automaticamente."));
-                println(chalk.gray(`  Abra manualmente: ${authUrl}\n`));
-            }
-        });
-        const result = await serverPromise;
-        code = result.code;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        eprintln(chalk.red(`  Erro: ${msg}`));
-        process.exit(1);
-    }
-    // Exchange code for JWT
-    process.stdout.write(chalk.gray("  Autenticando... "));
-    let token;
-    let userName;
-    try {
-        const result = await exchangeCodeForToken(code, url, "mcp");
-        token = result.token;
-        userName = result.userName;
-        println(chalk.green("OK"));
-        println(chalk.green(`  Logado como ${userName}\n`));
-    }
-    catch (err) {
-        println(chalk.red("FALHOU"));
-        eprintln(chalk.red(`  ${err instanceof Error ? err.message : String(err)}`));
-        process.exit(1);
-    }
-    // Configure all detected IDEs
-    println(chalk.gray("  Detectando IDEs...\n"));
-    const configured = await configureIDEs(token, url);
-    printSuccessBanner(configured);
-}
-/**
- * Uninstall flow
- */
-async function uninstall() {
-    printBanner();
-    if (!isTostudyMcpConfigured()) {
-        println(chalk.yellow("ToStudy MCP nao esta configurado."));
-        process.exit(0);
+function checkIDEInstallation() {
+  const installedIDEs = getInstalledIDEs();
+  if (installedIDEs.length === 0) {
+    return {
+      id: "no-ide-detected",
+      severity: "info",
+      title: "Nenhuma IDE suportada detectada",
+      description: "Nao foi encontrada nenhuma IDE compativel (VS Code, Cursor, JetBrains).",
+      suggestion: "Instale uma IDE suportada para usar a integracao completa.",
+      autoFixable: false
+    };
+  }
+  return null;
+}
+function checkDuplicateServers() {
+  const config = readClaudeConfig();
+  if (!config.mcpServers) {
+    return null;
+  }
+  const servers = Object.entries(config.mcpServers);
+  const anaServers = servers.filter(
+    ([key, server]) => key.toLowerCase().includes("ana") || key.toLowerCase().includes("catalyst") || server.url && server.url.includes("tostudy.com")
+  );
+  if (anaServers.length > 1) {
+    return {
+      id: "duplicate-servers",
+      severity: "warning",
+      title: "Multiplos servidores ToStudy configurados",
+      description: `Foram encontrados ${anaServers.length} servidores relacionados a ToStudy: ${anaServers.map(([k]) => k).join(", ")}.`,
+      suggestion: 'Execute "mcp-setup repair" para remover duplicatas ou limpe manualmente.',
+      autoFixable: true
+    };
+  }
+  return null;
+}
+async function runDiagnostics() {
+  const issues = [];
+  const syncChecks = [
+    checkClaudeInstallation(),
+    checkConfigFile(),
+    checkConfigJson(),
+    checkMcpConfiguration(),
+    checkApiKeyFormat(),
+    checkServerUrl(),
+    checkIDEInstallation(),
+    checkDuplicateServers()
+  ];
+  for (const issue of syncChecks) {
+    if (issue) {
+      issues.push(issue);
+    }
+  }
+  const hasConfigIssues = issues.some(
+    (issue) => ["config-invalid-json", "claude-not-installed"].includes(issue.id)
+  );
+  if (!hasConfigIssues) {
+    const asyncChecks = await Promise.all([checkPortConflict(), checkServerConnectivity()]);
+    for (const issue of asyncChecks) {
+      if (issue) {
+        issues.push(issue);
+      }
     }
-    const shouldUninstall = await confirm("Remover configuracao do ToStudy MCP?", false);
-    if (!shouldUninstall) {
-        println(chalk.gray("Operacao cancelada."));
-        process.exit(0);
+  }
+  const severityOrder = {
+    critical: 0,
+    warning: 1,
+    info: 2
+  };
+  issues.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  const hasCritical = issues.some((issue) => issue.severity === "critical");
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    claudeInstalled: isClaudeInstalled(),
+    mcpConfigured: isTostudyMcpConfigured(),
+    issues,
+    passed: !hasCritical
+  };
+}
+function getSeverityIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk.red("\u25CF");
+    case "warning":
+      return chalk.yellow("\u25CF");
+    case "info":
+      return chalk.blue("\u25CF");
+  }
+}
+function getSeverityLabel(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk.red("CRITICO");
+    case "warning":
+      return chalk.yellow("AVISO");
+    case "info":
+      return chalk.blue("INFO");
+  }
+}
+function printDiagnosticReport(report) {
+  println2();
+  println2(chalk.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  println2(
+    chalk.cyan("  \u2551") + chalk.white.bold("   ToStudy MCP Diagnostics        ") + chalk.cyan("\u2551")
+  );
+  println2(chalk.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  println2();
+  println2(chalk.gray("Status:"));
+  println2(
+    `  Claude Code: ${report.claudeInstalled ? chalk.green("\u2713 Instalado") : chalk.red("\u2717 Nao encontrado")}`
+  );
+  println2(
+    `  MCP ToStudy: ${report.mcpConfigured ? chalk.green("\u2713 Configurado") : chalk.yellow("\u25CB Nao configurado")}`
+  );
+  println2();
+  if (report.issues.length === 0) {
+    println2(chalk.green.bold("\u2713 Nenhum problema encontrado!"));
+    println2();
+    println2(chalk.gray("Tudo parece estar funcionando corretamente."));
+    println2();
+    return;
+  }
+  const criticalCount = report.issues.filter((i) => i.severity === "critical").length;
+  const warningCount = report.issues.filter((i) => i.severity === "warning").length;
+  const infoCount = report.issues.filter((i) => i.severity === "info").length;
+  println2(chalk.white.bold("Problemas encontrados:"));
+  if (criticalCount > 0) println2(`  ${chalk.red("\u25CF")} ${criticalCount} critico(s)`);
+  if (warningCount > 0) println2(`  ${chalk.yellow("\u25CF")} ${warningCount} aviso(s)`);
+  if (infoCount > 0) println2(`  ${chalk.blue("\u25CF")} ${infoCount} informativo(s)`);
+  println2();
+  for (const issue of report.issues) {
+    println2(
+      `${getSeverityIcon(issue.severity)} ${getSeverityLabel(issue.severity)}: ${chalk.white(issue.title)}`
+    );
+    println2(chalk.gray(`  ${issue.description}`));
+    println2(chalk.cyan(`  \u2192 ${issue.suggestion}`));
+    if (issue.autoFixable) {
+      println2(chalk.green(`  \u2713 Corrigivel automaticamente`));
     }
-    process.stdout.write(chalk.gray("Removendo configuracao... "));
+    println2();
+  }
+  if (report.passed) {
+    println2(chalk.yellow("\u26A0 Alguns avisos encontrados, mas o sistema deve funcionar."));
+  } else {
+    println2(chalk.red("\u2717 Problemas criticos precisam ser resolvidos."));
+    println2(chalk.gray('  Execute "npx @tostudy-ai/mcp-setup" para corrigir a configuracao.'));
+  }
+  println2();
+}
+function exportDiagnosticReportJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+if (process.argv[1]?.endsWith("diagnose.js")) {
+  (async () => {
     try {
-        removeTostudyMcpServer();
-        println(chalk.green("OK"));
-        println();
-        println(chalk.green("Configuracao removida com sucesso."));
-        println(chalk.gray("Reinicie o Claude Code para aplicar as mudancas."));
-        println();
-    }
-    catch (error) {
-        println(chalk.red("FALHOU"));
-        eprintln(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}
-/**
- * Print wizard step header
- */
-function printStep(step, total, title) {
-    println();
-    println(chalk.cyan(`━━━ Passo ${step}/${total}: ${title} ━━━`));
-    println();
+      const report = await runDiagnostics();
+      if (process.argv.includes("--json")) {
+        println2(exportDiagnosticReportJson(report));
+      } else {
+        printDiagnosticReport(report);
+      }
+      process.exit(report.passed ? 0 : 1);
+    } catch (error) {
+      process.stderr.write(chalk.red("Erro ao executar diagnostico:\n"));
+      process.stderr.write((error instanceof Error ? error.message : String(error)) + "\n");
+      process.exit(1);
+    }
+  })();
 }
-/**
- * Print IDE detection results
- */
-function printIDEDetection(installedIDEs) {
-    if (installedIDEs.length === 0) {
-        println(chalk.yellow("  Nenhuma IDE suportada detectada."));
-        println(chalk.gray("  O setup continuara para Claude Code."));
-    }
-    else {
-        println(chalk.green("  IDEs detectadas:"));
-        for (const ide of installedIDEs) {
-            const version = ide.version ? chalk.gray(` (${ide.version})`) : "";
-            println(`    ${chalk.green("✓")} ${ide.name}${version}`);
-        }
+
+// src/repair.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, copyFileSync as copyFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import chalk2 from "chalk";
+var DEFAULT_PLATFORM_URL = "https://tostudy.ai";
+function println3(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function repairMissingConfig() {
+  const configPath = getClaudeConfigPath();
+  const configDir = dirname2(configPath);
+  try {
+    if (!existsSync4(configDir)) {
+      mkdirSync2(configDir, { recursive: true });
     }
+    const initialConfig = {
+      mcpServers: {}
+    };
+    writeFileSync2(configPath, JSON.stringify(initialConfig, null, 2), "utf-8");
+    return {
+      issueId: "config-missing",
+      success: true,
+      message: "Arquivo de configuracao criado com sucesso.",
+      action: `Criado: ${configPath}`
+    };
+  } catch (error) {
+    return {
+      issueId: "config-missing",
+      success: false,
+      message: `Falha ao criar arquivo de configuracao: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
 }
-/**
- * Interactive wizard flow
- * Guides user through complete MCP setup with step-by-step instructions
- */
-async function wizard(options) {
-    const TOTAL_STEPS = 4;
-    // Print wizard banner
-    println();
-    println(chalk.cyan("  ╔═══════════════════════════════════════════════╗"));
-    println(chalk.cyan("  ║") +
-        chalk.white.bold("   ToStudy MCP Setup Wizard               ") +
-        chalk.cyan("║"));
-    println(chalk.cyan("  ║") + chalk.gray("   Configuracao guiada passo a passo       ") + chalk.cyan("║"));
-    println(chalk.cyan("  ╚═══════════════════════════════════════════════╝"));
-    println();
-    println(chalk.gray("  Este assistente vai configurar o Claude Code para"));
-    println(chalk.gray("  conectar ao servidor MCP da plataforma ToStudy."));
-    println();
-    // ━━━ Step 1: Environment Detection ━━━
-    printStep(1, TOTAL_STEPS, "Detectando ambiente");
-    // Check Claude Code
-    process.stdout.write("  Verificando Claude Code... ");
-    if (!isClaudeInstalled()) {
-        println(chalk.red("NAO ENCONTRADO"));
-        println();
-        println(chalk.red("  Claude Code nao esta instalado."));
-        println();
-        println("  Por favor, instale primeiro:");
-        println(chalk.cyan("    https://claude.ai/download"));
-        println();
-        process.exit(1);
-    }
-    println(chalk.green("OK"));
-    const configPath = getClaudeConfigPath();
-    println(chalk.gray(`    Config: ${configPath}`));
-    // Check for other IDEs
-    process.stdout.write("  Detectando IDEs... ");
-    const installedIDEs = getInstalledIDEs();
-    println(chalk.green("OK"));
-    printIDEDetection(installedIDEs);
-    // Check existing configuration
-    process.stdout.write("  Verificando configuracao atual... ");
-    const alreadyConfigured = isTostudyMcpConfigured();
-    if (alreadyConfigured) {
-        println(chalk.yellow("JA CONFIGURADO"));
-        println();
-        const overwrite = await confirm("  Deseja reconfigurar?", false);
-        if (!overwrite) {
-            println();
-            println(chalk.gray("  Operacao cancelada."));
-            process.exit(0);
+function repairInvalidJson() {
+  const configPath = getClaudeConfigPath();
+  try {
+    if (existsSync4(configPath)) {
+      const backupPath = `${configPath}.corrupted.${Date.now()}`;
+      copyFileSync2(configPath, backupPath);
+      const freshConfig = {
+        mcpServers: {}
+      };
+      writeFileSync2(configPath, JSON.stringify(freshConfig, null, 2), "utf-8");
+      return {
+        issueId: "config-invalid-json",
+        success: true,
+        message: "Arquivo de configuracao recriado. Backup salvo.",
+        action: `Backup: ${backupPath}`
+      };
+    }
+    return {
+      issueId: "config-invalid-json",
+      success: false,
+      message: "Arquivo de configuracao nao existe."
+    };
+  } catch (error) {
+    return {
+      issueId: "config-invalid-json",
+      success: false,
+      message: `Falha ao reparar JSON: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairMcpNotConfigured(apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
+  try {
+    addTostudyMcpServer(apiKey, platformUrl);
+    return {
+      issueId: "mcp-not-configured",
+      success: true,
+      message: "Servidor MCP da ToStudy configurado com sucesso.",
+      action: "Servidor tostudy adicionado"
+    };
+  } catch (error) {
+    return {
+      issueId: "mcp-not-configured",
+      success: false,
+      message: `Falha ao configurar MCP: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairApiKeyMissing(apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
+  try {
+    addTostudyMcpServer(apiKey, platformUrl);
+    return {
+      issueId: "api-key-missing",
+      success: true,
+      message: "API key configurada com sucesso.",
+      action: "Header Authorization adicionado"
+    };
+  } catch (error) {
+    return {
+      issueId: "api-key-missing",
+      success: false,
+      message: `Falha ao configurar API key: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairApiKeyFormat() {
+  const config = readClaudeConfig();
+  const mcpConfig = config.mcpServers?.["tostudy"];
+  if (!mcpConfig) {
+    return {
+      issueId: "api-key-invalid-format",
+      success: false,
+      message: "Servidor MCP nao esta configurado."
+    };
+  }
+  try {
+    if (mcpConfig.headers) {
+      const authHeader = mcpConfig.headers["Authorization"] || "";
+      if (authHeader && !authHeader.startsWith("Bearer ")) {
+        mcpConfig.headers["Authorization"] = `Bearer ${authHeader}`;
+        writeClaudeConfig(config);
+        return {
+          issueId: "api-key-invalid-format",
+          success: true,
+          message: "Formato de API key corrigido.",
+          action: 'Prefixo "Bearer " adicionado'
+        };
+      }
+    }
+    if (mcpConfig.args) {
+      for (let i = 0; i < mcpConfig.args.length; i++) {
+        if (mcpConfig.args[i] === "--header" && mcpConfig.args[i + 1]?.startsWith("Authorization:")) {
+          const value = mcpConfig.args[i + 1].replace("Authorization:", "");
+          if (value && !value.startsWith("Bearer ")) {
+            mcpConfig.args[i + 1] = `Authorization:Bearer ${value}`;
+            writeClaudeConfig(config);
+            return {
+              issueId: "api-key-invalid-format",
+              success: true,
+              message: "Formato de API key corrigido.",
+              action: 'Prefixo "Bearer " adicionado'
+            };
+          }
         }
+      }
     }
-    else {
-        println(chalk.gray("Nao configurado"));
+    return {
+      issueId: "api-key-invalid-format",
+      success: false,
+      message: "API key nao encontrada para corrigir."
+    };
+  } catch (error) {
+    return {
+      issueId: "api-key-invalid-format",
+      success: false,
+      message: `Falha ao corrigir formato: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairServerUrl(platformUrl = DEFAULT_PLATFORM_URL) {
+  const config = readClaudeConfig();
+  const mcpConfig = config.mcpServers?.["tostudy"];
+  if (!mcpConfig) {
+    return {
+      issueId: "server-url-missing",
+      success: false,
+      message: "Servidor MCP nao esta configurado."
+    };
+  }
+  try {
+    const apiKey = extractApiKey(mcpConfig);
+    if (!apiKey) {
+      return {
+        issueId: "server-url-missing",
+        success: false,
+        message: "API key nao encontrada para reconstruir configuracao."
+      };
     }
-    // ━━━ Step 2: API Key Configuration ━━━
-    printStep(2, TOTAL_STEPS, "Configurando API Key");
-    println(chalk.gray("  A API key conecta o Claude Code a sua conta na plataforma."));
-    println();
-    let apiKey = options.apiKey || process.env.TOSTUDY_API_KEY;
+    addTostudyMcpServer(apiKey, platformUrl);
+    return {
+      issueId: "server-url-missing",
+      success: true,
+      message: "URL do servidor configurada.",
+      action: `URL: ${platformUrl}/mcp`
+    };
+  } catch (error) {
+    return {
+      issueId: "server-url-missing",
+      success: false,
+      message: `Falha ao configurar URL: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairServerUrlProtocol(platformUrl = DEFAULT_PLATFORM_URL) {
+  const config = readClaudeConfig();
+  const mcpConfig = config.mcpServers?.["tostudy"];
+  if (!mcpConfig) {
+    return {
+      issueId: "server-url-invalid-protocol",
+      success: false,
+      message: "Servidor MCP nao esta configurado."
+    };
+  }
+  const url = extractMcpUrl(mcpConfig);
+  if (!url) {
+    return {
+      issueId: "server-url-invalid-protocol",
+      success: false,
+      message: "URL do servidor nao configurada."
+    };
+  }
+  try {
+    const fixedUrl = url.replace(/^[a-z]+:/, "https:");
+    const basePlatformUrl = fixedUrl.replace(/\/mcp(\/sse)?$/, "");
+    const apiKey = extractApiKey(mcpConfig);
     if (!apiKey) {
-        println("  Acesse sua API key em:");
-        println(chalk.cyan(`    ${options.url || DEFAULT_PLATFORM_URL}/student/settings/mcp`));
-        println();
-        apiKey = await promptApiKey();
-    }
-    else {
-        println(chalk.green("  ✓ API key fornecida via parametro ou ambiente"));
-    }
-    const platformUrl = options.url || process.env.TOSTUDY_PLATFORM_URL || DEFAULT_PLATFORM_URL;
-    // Validate API key
-    println();
-    process.stdout.write(chalk.gray("  Validando API key... "));
-    const valid = await validateApiKey(apiKey, platformUrl);
-    if (!valid) {
-        println(chalk.red("FALHOU"));
-        println();
-        println(chalk.red("  API key invalida ou expirada."));
-        println();
-        println("  Para gerar uma nova API key:");
-        println(chalk.cyan(`    ${platformUrl}/student/settings/mcp`));
-        println();
-        process.exit(1);
-    }
-    println(chalk.green("OK"));
-    // ━━━ Step 3: Save Configuration ━━━
-    printStep(3, TOTAL_STEPS, "Salvando configuracao");
-    process.stdout.write("  Configurando Claude Code... ");
-    try {
-        addTostudyMcpServer(apiKey, platformUrl);
-        println(chalk.green("OK"));
-    }
-    catch (error) {
-        println(chalk.red("FALHOU"));
-        eprintln();
-        eprintln(chalk.red("  Erro ao salvar configuracao:"));
-        eprintln("  " + (error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
-    // ━━━ Step 4: Diagnostics & Verification ━━━
-    printStep(4, TOTAL_STEPS, "Verificacao final");
-    if (!options.skipDiagnostics) {
-        process.stdout.write("  Executando diagnostico... ");
-        const report = await runDiagnostics();
-        println(chalk.green("OK"));
-        println();
-        // Filter out expected issues that we just fixed
-        const remainingIssues = report.issues.filter((issue) => !["mcp-not-configured", "config-missing"].includes(issue.id));
-        if (remainingIssues.length > 0) {
-            println(chalk.yellow("  Avisos encontrados:"));
-            for (const issue of remainingIssues) {
-                const icon = issue.severity === "critical"
-                    ? chalk.red("●")
-                    : issue.severity === "warning"
-                        ? chalk.yellow("●")
-                        : chalk.blue("●");
-                println(`    ${icon} ${issue.title}`);
-            }
-            println();
-            // Auto-repair if enabled
-            if (options.autoRepair) {
-                process.stdout.write("  Tentando reparar automaticamente... ");
-                const repairReport = repairAllIssues(report, apiKey, platformUrl);
-                if (repairReport.repairsSucceeded > 0) {
-                    println(chalk.green(`${repairReport.repairsSucceeded} corrigido(s)`));
-                }
-                else {
-                    println(chalk.yellow("Nenhum reparo aplicado"));
-                }
-            }
-            else {
-                println(chalk.gray('  Dica: Execute "npx @tostudy-ai/mcp-setup diagnose" para mais detalhes.'));
-            }
-        }
-        else {
-            println(chalk.green("  ✓ Nenhum problema encontrado!"));
-        }
+      return {
+        issueId: "server-url-invalid-protocol",
+        success: false,
+        message: "API key nao encontrada para reconstruir configuracao."
+      };
+    }
+    addTostudyMcpServer(apiKey, basePlatformUrl);
+    return {
+      issueId: "server-url-invalid-protocol",
+      success: true,
+      message: "Protocolo da URL corrigido para HTTPS.",
+      action: `URL: ${basePlatformUrl}/mcp`
+    };
+  } catch (error) {
+    return {
+      issueId: "server-url-invalid-protocol",
+      success: false,
+      message: `Falha ao corrigir protocolo: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairServerUrlPath() {
+  const config = readClaudeConfig();
+  const mcpConfig = config.mcpServers?.["tostudy"];
+  if (!mcpConfig) {
+    return {
+      issueId: "server-url-missing-sse-path",
+      success: false,
+      message: "Servidor MCP nao esta configurado."
+    };
+  }
+  const url = extractMcpUrl(mcpConfig);
+  if (!url) {
+    return {
+      issueId: "server-url-missing-sse-path",
+      success: false,
+      message: "URL do servidor nao configurada."
+    };
+  }
+  try {
+    const parsedUrl = new URL(url);
+    parsedUrl.pathname = parsedUrl.pathname.replace(/\/(mcp(\/sse)?)?$/, "");
+    const basePlatformUrl = parsedUrl.toString().replace(/\/$/, "");
+    const apiKey = extractApiKey(mcpConfig);
+    if (!apiKey) {
+      return {
+        issueId: "server-url-missing-sse-path",
+        success: false,
+        message: "API key nao encontrada para reconstruir configuracao."
+      };
     }
-    else {
-        println(chalk.gray("  Diagnostico ignorado (--skip-diagnostics)"));
-    }
-    // ━━━ Success ━━━
-    println();
-    println(chalk.green("  ╔═══════════════════════════════════════════════╗"));
-    println(chalk.green("  ║") +
-        chalk.white.bold("   Configuracao concluida com sucesso!     ") +
-        chalk.green("║"));
-    println(chalk.green("  ╚═══════════════════════════════════════════════╝"));
-    println();
-    println(chalk.white("  Proximos passos:"));
-    println();
-    println(chalk.gray("    1.") + " Reinicie o Claude Code");
-    println(chalk.gray("    2.") + " O servidor MCP iniciara automaticamente");
-    println(chalk.gray("    3.") + " Use " + chalk.cyan("/courses") + " para ver seus cursos");
-    println();
-    println(chalk.gray("  Comandos uteis:"));
-    println(chalk.gray("    ") +
-        chalk.cyan("npx @tostudy-ai/mcp-setup diagnose") +
-        chalk.gray(" - Verificar problemas"));
-    println(chalk.gray("    ") +
-        chalk.cyan("npx @tostudy-ai/mcp-setup repair") +
-        chalk.gray("   - Reparar automaticamente"));
-    println();
-    println(chalk.gray("  ─────────────────────────────────────────"));
-    println();
-    println(chalk.white("  Prefere estudar pelo terminal?"));
-    println(chalk.gray("    ") + chalk.cyan("npm install -g @tostudy-ai/cli"));
-    println(chalk.gray("    ") +
-        chalk.cyan("tostudy login") +
-        chalk.gray(" → ") +
-        chalk.cyan("tostudy courses"));
-    println();
-}
-// CLI setup
-program
-    .name("tostudy-mcp-setup")
-    .description("Configura o Claude Code para usar o ToStudy MCP server")
-    .version(VERSION);
-// Default command (setup)
-program
-    .option("-k, --api-key <key>", "API key (fallback para ambientes sem browser)")
-    .option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)")
-    .option("--uninstall", "Remove a configuracao do ToStudy MCP")
-    .action(async (options) => {
+    addTostudyMcpServer(apiKey, basePlatformUrl);
+    return {
+      issueId: "server-url-missing-sse-path",
+      success: true,
+      message: "Path /mcp corrigido na URL.",
+      action: `URL: ${basePlatformUrl}/mcp`
+    };
+  } catch (error) {
+    return {
+      issueId: "server-url-missing-sse-path",
+      success: false,
+      message: `Falha ao corrigir path: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function repairDuplicateServers() {
+  const config = readClaudeConfig();
+  if (!config.mcpServers) {
+    return {
+      issueId: "duplicate-servers",
+      success: false,
+      message: "Nenhum servidor MCP configurado."
+    };
+  }
+  try {
+    const servers = Object.entries(config.mcpServers);
+    const anaServers = servers.filter(
+      ([key, server]) => key.toLowerCase().includes("ana") || key.toLowerCase().includes("catalyst") || server.url && server.url.includes("tostudy.com")
+    );
+    if (anaServers.length <= 1) {
+      return {
+        issueId: "duplicate-servers",
+        success: true,
+        message: "Nenhuma duplicata encontrada."
+      };
+    }
+    const primaryKey = anaServers.find(([key]) => key === "tostudy")?.[0] || anaServers[0][0];
+    const removedKeys = [];
+    for (const [key] of anaServers) {
+      if (key !== primaryKey) {
+        delete config.mcpServers[key];
+        removedKeys.push(key);
+      }
+    }
+    writeClaudeConfig(config);
+    return {
+      issueId: "duplicate-servers",
+      success: true,
+      message: `${removedKeys.length} servidor(es) duplicado(s) removido(s).`,
+      action: `Removidos: ${removedKeys.join(", ")}`
+    };
+  } catch (error) {
+    return {
+      issueId: "duplicate-servers",
+      success: false,
+      message: `Falha ao remover duplicatas: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+var REPAIR_FUNCTIONS = {
+  "config-missing": () => repairMissingConfig(),
+  "config-invalid-json": () => repairInvalidJson(),
+  "mcp-not-configured": (apiKey, platformUrl) => {
+    if (!apiKey) {
+      return {
+        issueId: "mcp-not-configured",
+        success: false,
+        message: "API key necessaria para configurar o MCP."
+      };
+    }
+    return repairMcpNotConfigured(apiKey, platformUrl);
+  },
+  "api-key-missing": (apiKey, platformUrl) => {
+    if (!apiKey) {
+      return {
+        issueId: "api-key-missing",
+        success: false,
+        message: "Nova API key necessaria."
+      };
+    }
+    return repairApiKeyMissing(apiKey, platformUrl);
+  },
+  "api-key-invalid-format": () => repairApiKeyFormat(),
+  "api-key-too-short": (apiKey, platformUrl) => {
+    if (!apiKey) {
+      return {
+        issueId: "api-key-too-short",
+        success: false,
+        message: "Nova API key necessaria."
+      };
+    }
+    return repairApiKeyMissing(apiKey, platformUrl);
+  },
+  "server-url-missing": (_, platformUrl) => repairServerUrl(platformUrl),
+  "server-url-invalid": (_, platformUrl) => repairServerUrl(platformUrl),
+  "server-url-invalid-protocol": () => repairServerUrlProtocol(),
+  "server-url-missing-sse-path": () => repairServerUrlPath(),
+  "auth-failed": (apiKey, platformUrl) => {
+    if (!apiKey) {
+      return {
+        issueId: "auth-failed",
+        success: false,
+        message: "Nova API key necessaria. Gere em /student/settings/mcp."
+      };
+    }
+    return repairMcpNotConfigured(apiKey, platformUrl);
+  },
+  "duplicate-servers": () => repairDuplicateServers()
+};
+var ISSUES_REQUIRING_API_KEY = [
+  "mcp-not-configured",
+  "api-key-missing",
+  "api-key-too-short",
+  "auth-failed"
+];
+function issueRequiresUserInput(issueId) {
+  return ISSUES_REQUIRING_API_KEY.includes(issueId);
+}
+function repairIssue(issue, apiKey, platformUrl) {
+  const repairFn = REPAIR_FUNCTIONS[issue.id];
+  if (!repairFn) {
+    return {
+      issueId: issue.id,
+      success: false,
+      message: `Sem funcao de reparo disponivel para: ${issue.id}`
+    };
+  }
+  return repairFn(apiKey, platformUrl);
+}
+function repairAllIssues(report, apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
+  const results = [];
+  const requiresUserInput = [];
+  let succeeded = 0;
+  let failed = 0;
+  const fixableIssues = report.issues.filter((issue) => issue.autoFixable);
+  for (const issue of fixableIssues) {
+    if (issueRequiresUserInput(issue.id) && !apiKey) {
+      requiresUserInput.push(issue.id);
+      results.push({
+        issueId: issue.id,
+        success: false,
+        message: "Requer API key para reparar."
+      });
+      failed++;
+      continue;
+    }
+    const result = repairIssue(issue, apiKey, platformUrl);
+    results.push(result);
+    if (result.success) {
+      succeeded++;
+    } else {
+      failed++;
+    }
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    repairsAttempted: fixableIssues.length,
+    repairsSucceeded: succeeded,
+    repairsFailed: failed,
+    results,
+    requiresUserInput
+  };
+}
+async function diagnoseAndRepair(apiKey, platformUrl = DEFAULT_PLATFORM_URL) {
+  const diagnostic = await runDiagnostics();
+  const repair = repairAllIssues(diagnostic, apiKey, platformUrl);
+  return { diagnostic, repair };
+}
+function printRepairReport(report) {
+  println3();
+  println3(chalk2.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  println3(
+    chalk2.cyan("  \u2551") + chalk2.white.bold("   ToStudy MCP Auto-Repair        ") + chalk2.cyan("\u2551")
+  );
+  println3(chalk2.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  println3();
+  if (report.repairsAttempted === 0) {
+    println3(chalk2.green.bold("\u2713 Nenhum reparo necessario!"));
+    println3();
+    println3(chalk2.gray("Nenhum problema corrigivel automaticamente foi encontrado."));
+    println3();
+    return;
+  }
+  println3(chalk2.white.bold("Resumo:"));
+  println3(`  Reparos tentados: ${report.repairsAttempted}`);
+  println3(`  ${chalk2.green("\u2713 Sucesso:")} ${report.repairsSucceeded}`);
+  if (report.repairsFailed > 0) {
+    println3(`  ${chalk2.red("\u2717 Falha:")} ${report.repairsFailed}`);
+  }
+  println3();
+  println3(chalk2.white.bold("Detalhes:"));
+  println3();
+  for (const result of report.results) {
+    if (result.success) {
+      println3(`  ${chalk2.green("\u2713")} ${result.message}`);
+      if (result.action) {
+        println3(chalk2.gray(`    ${result.action}`));
+      }
+    } else {
+      println3(`  ${chalk2.red("\u2717")} ${result.message}`);
+    }
+  }
+  println3();
+  if (report.requiresUserInput.length > 0) {
+    println3(chalk2.yellow("\u26A0 Alguns reparos requerem interacao:"));
+    println3();
+    println3("  Para reparar problemas de API key, execute:");
+    println3(chalk2.cyan("    npx @tostudy-ai/mcp-setup repair --api-key <sua-api-key>"));
+    println3();
+    println3("  Para gerar uma nova API key:");
+    println3(chalk2.cyan("    https://tostudy.ai/student/settings/mcp"));
+    println3();
+  }
+  if (report.repairsFailed === 0 && report.requiresUserInput.length === 0) {
+    println3(chalk2.green.bold("\u2713 Todos os reparos concluidos com sucesso!"));
+    println3(chalk2.gray("  Reinicie o Claude Code para aplicar as mudancas."));
+  } else if (report.repairsSucceeded > 0) {
+    println3(chalk2.yellow("\u26A0 Alguns reparos foram concluidos, mas outros falharam."));
+    println3(chalk2.gray("  Execute o diagnostico novamente para verificar o status."));
+  } else {
+    println3(chalk2.red("\u2717 Nenhum reparo foi concluido com sucesso."));
+    println3(chalk2.gray("  Verifique os erros acima e tente novamente."));
+  }
+  println3();
+}
+if (process.argv[1]?.endsWith("repair.js")) {
+  (async () => {
     try {
-        if (options.uninstall) {
-            await uninstall();
-        }
-        else {
-            await setup(options.apiKey, options.url);
+      let apiKey;
+      let platformUrl = DEFAULT_PLATFORM_URL;
+      let jsonOutput = false;
+      for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === "--api-key" && process.argv[i + 1]) {
+          apiKey = process.argv[++i];
+        } else if (arg === "--url" && process.argv[i + 1]) {
+          platformUrl = process.argv[++i];
+        } else if (arg === "--json") {
+          jsonOutput = true;
+        } else if (arg === "--help" || arg === "-h") {
+          println3("ToStudy MCP Auto-Repair");
+          println3();
+          println3("Usage: node repair.js [options]");
+          println3();
+          println3("Options:");
+          println3("  --api-key <key>  API key para reparos que necessitam autenticacao");
+          println3("  --url <url>      URL da plataforma (default: https://tostudy.ai)");
+          println3("  --json           Saida em formato JSON");
+          println3("  --help, -h       Mostra esta ajuda");
+          println3();
+          process.exit(0);
         }
+      }
+      if (!apiKey) {
+        apiKey = process.env.TOSTUDY_API_KEY;
+      }
+      const { diagnostic, repair } = await diagnoseAndRepair(apiKey, platformUrl);
+      if (jsonOutput) {
+        println3(JSON.stringify({ diagnostic, repair }, null, 2));
+      } else {
+        printRepairReport(repair);
+      }
+      const hasUnfixedCritical = diagnostic.issues.some(
+        (issue) => issue.severity === "critical" && !repair.results.find((r) => r.issueId === issue.id && r.success)
+      );
+      process.exit(hasUnfixedCritical ? 1 : 0);
+    } catch (error) {
+      process.stderr.write(chalk2.red("Erro ao executar reparo:\n"));
+      process.stderr.write((error instanceof Error ? error.message : String(error)) + "\n");
+      process.exit(1);
     }
-    catch (error) {
-        eprintln();
-        eprintln(chalk.red("Erro:") + " " + (error instanceof Error ? error.message : String(error)));
-        process.exit(1);
+  })();
+}
+
+// src/ide-handlers/claude-code.ts
+import { execFileSync } from "child_process";
+
+// src/ide-handlers/base.ts
+import { platform as platform3 } from "os";
+function buildMcpRemoteArgs(apiKey, mcpUrl, ide) {
+  const osHeader = getClientOsHeaderValue2();
+  return [
+    "-y",
+    "mcp-remote",
+    `${mcpUrl}/mcp`,
+    "--header",
+    `Authorization:Bearer ${apiKey}`,
+    "--header",
+    `X-Tostudy-Client-IDE:${ide}`,
+    "--header",
+    `X-Tostudy-Client-OS:${osHeader}`
+  ];
+}
+function buildTostudyServerEntry(apiKey, mcpUrl, ide) {
+  return {
+    command: "npx",
+    args: buildMcpRemoteArgs(apiKey, mcpUrl, ide)
+  };
+}
+function getClientOsHeaderValue2() {
+  switch (platform3()) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return "linux";
+  }
+}
+async function verifyHeartbeat(apiKey, platformUrl) {
+  try {
+    const response = await fetch(`${platformUrl}/api/mcp/heartbeat`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+    });
+    return response.ok || response.status === 204;
+  } catch {
+    return false;
+  }
+}
+
+// src/ide-handlers/claude-code.ts
+function parseClaudeCodeScope(answer) {
+  return answer.trim().toLowerCase().startsWith("l") ? "project" : "user";
+}
+async function promptClaudeCodeScope(promptFn = prompt) {
+  const answer = await promptFn(
+    "  Claude Code: configurar global ou local? (g/l, padr\xE3o: global) "
+  );
+  return parseClaudeCodeScope(answer);
+}
+function buildClaudeCodeAddArgs(apiKey, mcpUrl, scope) {
+  return [
+    "mcp",
+    "add",
+    "tostudy",
+    "--scope",
+    scope,
+    "--",
+    "npx",
+    ...buildMcpRemoteArgs(apiKey, mcpUrl, "claude-code")
+  ];
+}
+function buildClaudeCodeRemoveArgs(scope) {
+  return ["mcp", "remove", "tostudy", "--scope", scope];
+}
+var ClaudeCodeHandler = class {
+  id = "claude-code";
+  name = "Claude Code";
+  async detect() {
+    try {
+      execFileSync("which", ["claude"], { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        execFileSync("where", ["claude"], { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
     }
-});
-// Wizard command - interactive step-by-step setup
-program
-    .command("wizard")
-    .description("Assistente interativo de configuracao passo a passo")
-    .option("-k, --api-key <key>", "API key da plataforma ToStudy")
-    .option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)")
-    .option("--skip-diagnostics", "Pula a verificacao de diagnostico apos setup")
-    .option("--auto-repair", "Tenta reparar problemas automaticamente")
-    .action(async (options) => {
+  }
+  getConfigPath() {
+    return "Terminal (claude mcp add)";
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const scope = await promptClaudeCodeScope();
+    const addArgs = buildClaudeCodeAddArgs(apiKey, mcpUrl, scope);
+    const removeArgs = buildClaudeCodeRemoveArgs(scope);
     try {
-        await wizard({
-            apiKey: options.apiKey,
-            url: options.url,
-            skipDiagnostics: options.skipDiagnostics,
-            autoRepair: options.autoRepair,
-        });
-    }
-    catch (error) {
-        eprintln();
-        eprintln(chalk.red("Erro:") + " " + (error instanceof Error ? error.message : String(error)));
-        process.exit(1);
+      try {
+        execFileSync("claude", removeArgs, { stdio: "ignore" });
+      } catch {
+      }
+      execFileSync("claude", addArgs, { stdio: "inherit" });
+    } catch (error) {
+      throw new Error(
+        `Failed to run 'claude mcp add'. Is Claude Code installed?
+Error: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-});
-// Diagnose command
-program
-    .command("diagnose")
-    .description("Executa diagnostico de problemas na configuracao MCP")
-    .option("--json", "Saida em formato JSON")
-    .action(async (options) => {
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/cursor.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+import { homedir as homedir3, platform as platform4 } from "os";
+var CursorHandler = class {
+  id = "cursor";
+  name = "Cursor";
+  async detect() {
+    const home = homedir3();
+    const os = platform4();
+    switch (os) {
+      case "darwin":
+        return existsSync5(join3("/Applications", "Cursor.app")) || existsSync5(join3(home, "Applications", "Cursor.app"));
+      case "win32": {
+        const localAppData = process.env.LOCALAPPDATA || join3(home, "AppData", "Local");
+        return existsSync5(join3(localAppData, "Programs", "cursor", "Cursor.exe"));
+      }
+      case "linux":
+        return existsSync5(join3(home, ".cursor"));
+      default:
+        return false;
+    }
+  }
+  getConfigPath() {
+    const home = homedir3();
+    return join3(home, ".cursor", "mcp.json");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname3(configPath);
+    if (!existsSync5(configDir)) {
+      mkdirSync3(configDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync5(configPath)) {
+      try {
+        config = JSON.parse(readFileSync3(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    const mcpServers = config.mcpServers ?? {};
+    mcpServers["tostudy"] = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.mcpServers = mcpServers;
+    writeFileSync3(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/vscode.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4, dirname as dirname4 } from "path";
+import { homedir as homedir4, platform as platform5 } from "os";
+var VSCodeHandler = class {
+  id = "vscode";
+  name = "VS Code";
+  async detect() {
+    const home = homedir4();
+    const os = platform5();
+    switch (os) {
+      case "darwin":
+        return existsSync6(join4("/Applications", "Visual Studio Code.app")) || existsSync6(join4(home, "Applications", "Visual Studio Code.app"));
+      case "win32": {
+        const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+        const localAppData = process.env.LOCALAPPDATA || join4(home, "AppData", "Local");
+        return existsSync6(join4(programFiles, "Microsoft VS Code", "Code.exe")) || existsSync6(join4(localAppData, "Programs", "Microsoft VS Code", "Code.exe"));
+      }
+      case "linux":
+        return existsSync6("/usr/bin/code") || existsSync6("/usr/local/bin/code");
+      default:
+        return false;
+    }
+  }
+  getConfigPath() {
+    return join4(process.cwd(), ".vscode", "mcp.json");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname4(configPath);
+    if (!existsSync6(configDir)) {
+      mkdirSync4(configDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync6(configPath)) {
+      try {
+        config = JSON.parse(readFileSync4(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    const servers = config.servers ?? {};
+    servers["tostudy"] = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.servers = servers;
+    writeFileSync4(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/desktop.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, copyFileSync as copyFileSync3 } from "fs";
+import { dirname as dirname5 } from "path";
+var DesktopHandler = class {
+  id = "desktop";
+  name = "Claude Desktop";
+  async detect() {
+    return isClaudeInstalled();
+  }
+  getConfigPath() {
+    return getClaudeConfigPath();
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname5(configPath);
+    if (!existsSync7(configDir)) {
+      mkdirSync5(configDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync7(configPath)) {
+      try {
+        config = JSON.parse(readFileSync5(configPath, "utf-8"));
+      } catch {
+      }
+      const backupPath = `${configPath}.backup`;
+      copyFileSync3(configPath, backupPath);
+    }
+    const mcpServers = config.mcpServers ?? {};
+    mcpServers["tostudy"] = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.mcpServers = mcpServers;
+    writeFileSync5(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/windsurf.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { join as join5, dirname as dirname6 } from "path";
+import { homedir as homedir5 } from "os";
+var WindsurfHandler = class {
+  id = "windsurf";
+  name = "Windsurf";
+  async detect() {
+    const home = homedir5();
+    return existsSync8(join5(home, ".codeium", "windsurf")) || existsSync8(join5(home, ".codeium", "windsurf", "mcp_config.json"));
+  }
+  getConfigPath() {
+    return join5(homedir5(), ".codeium", "windsurf", "mcp_config.json");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname6(configPath);
+    if (!existsSync8(configDir)) {
+      mkdirSync6(configDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync8(configPath)) {
+      try {
+        config = JSON.parse(readFileSync6(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    const mcpServers = config.mcpServers ?? {};
+    mcpServers.tostudy = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.mcpServers = mcpServers;
+    writeFileSync6(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/opencode.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+import { join as join6, dirname as dirname7 } from "path";
+import { homedir as homedir6 } from "os";
+var OpenCodeHandler = class {
+  id = "opencode";
+  name = "OpenCode";
+  async detect() {
     try {
-        const report = await runDiagnostics();
-        if (options.json) {
-            println(JSON.stringify(report, null, 2));
-        }
-        else {
-            printDiagnosticReport(report);
-        }
-        process.exit(report.passed ? 0 : 1);
+      execFileSync2("which", ["opencode"], { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        execFileSync2("where", ["opencode"], { stdio: "ignore" });
+        return true;
+      } catch {
+        return existsSync9(join6(homedir6(), ".opencode"));
+      }
     }
-    catch (error) {
-        eprintln();
-        eprintln(chalk.red("Erro ao executar diagnostico:"));
-        eprintln(error instanceof Error ? error.message : String(error));
-        process.exit(1);
+  }
+  getConfigPath() {
+    return join6(homedir6(), ".opencode", "opencode.json");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname7(configPath);
+    if (!existsSync9(configDir)) {
+      mkdirSync7(configDir, { recursive: true });
     }
-});
-// Repair command
-program
-    .command("repair")
-    .description("Repara problemas de configuracao automaticamente")
-    .option("-k, --api-key <key>", "API key para reparos que necessitam autenticacao")
-    .option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)")
-    .option("--json", "Saida em formato JSON")
-    .action(async (options) => {
+    let config = {};
+    if (existsSync9(configPath)) {
+      try {
+        config = JSON.parse(readFileSync7(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    const mcp = config.mcp ?? {};
+    mcp["tostudy"] = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.mcp = mcp;
+    writeFileSync7(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/codex.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
+var CodexHandler = class {
+  id = "codex";
+  name = "Codex";
+  async detect() {
     try {
-        const apiKey = options.apiKey || process.env.TOSTUDY_API_KEY;
-        const platformUrl = options.url || DEFAULT_PLATFORM_URL;
-        const diagnostic = await runDiagnostics();
-        const repair = repairAllIssues(diagnostic, apiKey, platformUrl);
-        if (options.json) {
-            println(JSON.stringify({ diagnostic, repair }, null, 2));
-        }
-        else {
-            printRepairReport(repair);
+      execFileSync3("which", ["codex"], { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        execFileSync3("where", ["codex"], { stdio: "ignore" });
+        return true;
+      } catch {
+        return existsSync10(join7(homedir7(), ".codex"));
+      }
+    }
+  }
+  getConfigPath() {
+    return join7(homedir7(), ".codex", "config.toml");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const args = buildMcpRemoteArgs(apiKey, mcpUrl, this.id);
+    try {
+      try {
+        execFileSync3("codex", ["mcp", "remove", "tostudy"], { stdio: "ignore" });
+      } catch {
+      }
+      execFileSync3("codex", ["mcp", "add", "tostudy", "--", "npx", ...args], { stdio: "inherit" });
+    } catch (error) {
+      throw new Error(
+        `Failed to run 'codex mcp add'. Is Codex installed?
+Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/antigravity.ts
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join8, dirname as dirname8 } from "path";
+import { homedir as homedir8 } from "os";
+var AntigravityHandler = class {
+  id = "antigravity";
+  name = "Antigravity";
+  async detect() {
+    const home = homedir8();
+    return existsSync11(join8(home, ".gemini", "antigravity")) || existsSync11(join8(home, ".gemini", "antigravity", "mcp_config.json"));
+  }
+  getConfigPath() {
+    return join8(homedir8(), ".gemini", "antigravity", "mcp_config.json");
+  }
+  async writeConfig(apiKey, mcpUrl) {
+    const configPath = this.getConfigPath();
+    const configDir = dirname8(configPath);
+    if (!existsSync11(configDir)) {
+      mkdirSync8(configDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync11(configPath)) {
+      try {
+        config = JSON.parse(readFileSync8(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    const mcpServers = config.mcpServers ?? {};
+    mcpServers.tostudy = buildTostudyServerEntry(apiKey, mcpUrl, this.id);
+    config.mcpServers = mcpServers;
+    writeFileSync8(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/manual.ts
+import chalk3 from "chalk";
+var TOKEN_PLACEHOLDER = "<SUBSTITUA_PELO_SEU_TOKEN_TOSTUDY>";
+var ManualHandler = class {
+  id = "manual";
+  name = "Manual";
+  async detect() {
+    return true;
+  }
+  getConfigPath() {
+    return "stdout";
+  }
+  async writeConfig(_apiKey, mcpUrl) {
+    const config = {
+      mcpServers: {
+        tostudy: buildTostudyServerEntry(TOKEN_PLACEHOLDER, mcpUrl, this.id)
+      }
+    };
+    process.stdout.write("\n");
+    process.stdout.write(
+      chalk3.cyan(
+        "Add the following to your MCP config and replace the token placeholder manually:\n"
+      )
+    );
+    process.stdout.write("\n");
+    process.stdout.write(JSON.stringify(config, null, 2));
+    process.stdout.write("\n\n");
+  }
+  async verify(apiKey, mcpUrl) {
+    return verifyHeartbeat(apiKey, mcpUrl);
+  }
+};
+
+// src/ide-handlers/index.ts
+var handlers = {
+  "claude-code": () => new ClaudeCodeHandler(),
+  "cursor": () => new CursorHandler(),
+  "vscode": () => new VSCodeHandler(),
+  "desktop": () => new DesktopHandler(),
+  "windsurf": () => new WindsurfHandler(),
+  "opencode": () => new OpenCodeHandler(),
+  "codex": () => new CodexHandler(),
+  "antigravity": () => new AntigravityHandler(),
+  "manual": () => new ManualHandler()
+};
+function getIDEHandler(ide) {
+  const factory = handlers[ide];
+  if (!factory) {
+    throw new Error(`Unknown IDE: ${ide}. Supported: ${Object.keys(handlers).join(", ")}`);
+  }
+  return factory();
+}
+function getAllIDEHandlers() {
+  return Object.values(handlers).map((factory) => factory());
+}
+async function detectInstalledIDEs() {
+  const all = getAllIDEHandlers();
+  const results = [];
+  for (const handler of all) {
+    if (await handler.detect()) {
+      results.push(handler);
+    }
+  }
+  return results;
+}
+
+// src/messages.ts
+var NEXT_STEPS_TITLE = "  Pr\xF3ximos passos:";
+var ASSISTANT_COURSES_PROMPT = '  Pe\xE7a ao assistente: "mostre meus cursos"';
+var COURSES_TOOL_HINT = '  Use a ferramenta "courses" para ver seus cursos';
+var API_KEY_DEPRECATION_WARNING = "\u26A0 The --api-key flag is deprecated and will be removed in a future version. Use the default OAuth flow instead: npx @tostudy-ai/mcp-setup";
+
+// src/oauth-server.ts
+import http from "http";
+
+// src/callback-page.ts
+function getCallbackPageHtml() {
+  return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>ToStudy \u2014 Autenticado</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      background: #0a0a0a;
+      color: #fafafa;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    .checkmark-circle {
+      width: 80px;
+      height: 80px;
+      border-radius: 50%;
+      border: 3px solid #22d3ee;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 1.5rem;
+      animation: scaleIn 0.4s ease-out;
+    }
+    .checkmark {
+      width: 40px;
+      height: 40px;
+      stroke: #22d3ee;
+      stroke-width: 3;
+      fill: none;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+      stroke-dasharray: 50;
+      stroke-dashoffset: 50;
+      animation: draw 0.5s ease-out 0.3s forwards;
+    }
+    h1 {
+      font-size: 1.5rem;
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+    }
+    .subtitle {
+      color: #a1a1aa;
+      font-size: 0.95rem;
+      margin-bottom: 0.25rem;
+    }
+    .brand {
+      color: #22d3ee;
+      font-size: 0.85rem;
+      margin-top: 2rem;
+      letter-spacing: 0.05em;
+    }
+    @keyframes scaleIn {
+      from { transform: scale(0); opacity: 0; }
+      to { transform: scale(1); opacity: 1; }
+    }
+    @keyframes draw {
+      to { stroke-dashoffset: 0; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="checkmark-circle">
+      <svg class="checkmark" viewBox="0 0 40 40">
+        <polyline points="12,20 18,26 28,14" />
+      </svg>
+    </div>
+    <h1>Autenticado com sucesso!</h1>
+    <p class="subtitle">Pode voltar ao terminal.</p>
+    <p class="subtitle" id="close-msg">Esta aba ser\xE1 fechada automaticamente.</p>
+    <p class="brand">ToStudy</p>
+  </div>
+  <script>
+    setTimeout(function() {
+      window.close();
+      document.getElementById('close-msg').textContent = 'Pode fechar esta aba manualmente.';
+    }, 3000);
+  </script>
+</body>
+</html>`;
+}
+
+// src/oauth-server.ts
+function startCallbackServer(port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(getCallbackPageHtml());
+          server.close();
+          resolve({ code });
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing code");
         }
-        const hasUnfixedCritical = diagnostic.issues.some((issue) => issue.severity === "critical" &&
-            !repair.results.find((r) => r.issueId === issue.id && r.success));
-        process.exit(hasUnfixedCritical ? 1 : 0);
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+      }
+    });
+    server.listen(port, () => {
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Porta ${port} em uso. Tente novamente ou use --api-key.`));
+      } else {
+        reject(err);
+      }
+    });
+    const timeoutId = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timeout \u2014 nenhuma resposta em 2 minutos."));
+    }, 12e4);
+    timeoutId.unref();
+  });
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname9, join as join10 } from "path";
+import chalk4 from "chalk";
+
+// ../mcp-cli-core/src/detect-ide.ts
+var IDE_DETECTION_RULES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    envVars: ["CLAUDE_CODE"]
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    envVars: ["CURSOR_TRACE_ID", "CURSOR_CHANNEL"]
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    envVars: ["CODEX"]
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    envVars: ["WINDSURF_PID"]
+  },
+  {
+    id: "vscode",
+    name: "VS Code",
+    envVars: ["VSCODE_PID", "VSCODE_IPC_HOOK"]
+  }
+];
+async function detectRunningIDE() {
+  for (const rule of IDE_DETECTION_RULES) {
+    if (rule.envVars.some((envVar) => process.env[envVar] !== void 0)) {
+      return {
+        id: rule.id,
+        name: rule.name,
+        detected: true
+      };
     }
-    catch (error) {
-        eprintln();
-        eprintln(chalk.red("Erro ao executar reparo:"));
-        eprintln(error instanceof Error ? error.message : String(error));
-        process.exit(1);
+  }
+  if (process.env.TERM_PROGRAM?.toLowerCase().includes("vscode")) {
+    return {
+      id: "vscode",
+      name: "VS Code",
+      detected: true
+    };
+  }
+  return null;
+}
+
+// ../mcp-cli-core/src/detect-node.ts
+import * as childProcess from "child_process";
+
+// ../mcp-cli-core/src/detect-workspace.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join9 } from "path";
+async function detectWorkspaceScenario(cwd) {
+  const hasAgentsMd = existsSync12(join9(cwd, "AGENTS.md")) || existsSync12(join9(cwd, "CLAUDE.md"));
+  const hasCursorRules = existsSync12(join9(cwd, ".cursor", "rules"));
+  const hasCopilotInstructions = existsSync12(join9(cwd, ".github", "copilot-instructions.md"));
+  return {
+    scenario: hasAgentsMd ? "existing" : "empty",
+    cwd,
+    hasAgentsMd,
+    hasCursorRules,
+    hasCopilotInstructions
+  };
+}
+
+// ../mcp-cli-core/src/generate-instructions.ts
+var CLI_COMMANDS = [
+  { command: "tostudy start", description: "Carrega o pr\xF3ximo m\xF3dulo", category: "learning" },
+  { command: "tostudy next", description: "Avan\xE7a para a pr\xF3xima li\xE7\xE3o", category: "learning" },
+  {
+    command: "tostudy hint",
+    description: "Mostra dicas progressivas para o exerc\xEDcio atual",
+    category: "learning"
+  },
+  {
+    command: "tostudy validate",
+    description: "Valida o exerc\xEDcio antes de avan\xE7ar",
+    category: "learning"
+  },
+  { command: "tostudy progress", description: "Mostra o progresso do curso", category: "learning" },
+  {
+    command: "tostudy workspace",
+    description: "Cria ou atualiza o workspace local",
+    category: "workspace"
+  }
+];
+function formatModuleMarker(module, currentModule) {
+  if (module.completed) {
+    return "\u2705";
+  }
+  if (module.order === currentModule) {
+    return "\u{1F504}";
+  }
+  return "\u2B1A";
+}
+function formatModuleList(modules, currentModule) {
+  return [...modules].sort((left, right) => left.order - right.order).map((module) => {
+    const suffix = module.order === currentModule ? " (atual)" : "";
+    return `${module.order}. ${formatModuleMarker(module, currentModule)} ${module.title}${suffix}`;
+  }).join("\n");
+}
+function formatToolList(tools) {
+  return tools.map((tool) => `- \`${tool.command}\` \u2014 ${tool.description}`).join("\n");
+}
+function generateMcpContent(course) {
+  const learningTools = course.availableTools.filter((tool) => tool.category === "learning");
+  const workspaceTools = course.availableTools.filter((tool) => tool.category === "workspace");
+  const hintTool = learningTools.find((tool) => tool.command.includes("hint"));
+  const validateTool = learningTools.find((tool) => tool.command.includes("validate"));
+  return `# ${course.title} \u2014 Guia de Estudo
+
+## Progresso Atual
+
+- M\xF3dulo ${course.currentModule} de ${course.totalModules} (${course.progressPercent}% completo)
+- Li\xE7\xE3o atual: ${course.currentModule}.${course.currentLesson} \u2014 ${course.currentLessonTitle}
+
+## Tools Dispon\xEDveis (MCP)
+
+### Aprendizado
+
+${formatToolList(learningTools)}
+
+${workspaceTools.length > 0 ? `### Workspace
+
+${formatToolList(workspaceTools)}
+
+` : ""}## Como Guiar o Aluno
+
+- Apresente o conte\xFAdo da li\xE7\xE3o antes de propor exerc\xEDcios
+${hintTool ? `- Use \`${hintTool.command}\` antes de entregar a resposta` : ""}
+${validateTool ? `- Valide com \`${validateTool.command}\` antes de avan\xE7ar` : ""}
+- Respeite a sequ\xEAncia dos m\xF3dulos
+
+## M\xF3dulos
+
+${formatModuleList(course.modules, course.currentModule)}
+
+---
+
+_ToStudy Platform \u2014 Criado por ${course.creator.name}_
+_Atualizado via \`tostudy sync\`_`;
+}
+function generateCliContent(course) {
+  const learningCommands = CLI_COMMANDS.filter((tool) => tool.category === "learning");
+  const workspaceCommands = CLI_COMMANDS.filter((tool) => tool.category === "workspace");
+  return `# ${course.title} \u2014 Guia de Estudo
+
+## Progresso Atual
+
+- M\xF3dulo ${course.currentModule} de ${course.totalModules} (${course.progressPercent}% completo)
+- Li\xE7\xE3o atual: ${course.currentModule}.${course.currentLesson} \u2014 ${course.currentLessonTitle}
+
+## Comandos CLI Dispon\xEDveis
+
+### Aprendizado
+
+${formatToolList(learningCommands)}
+
+### Workspace
+
+${formatToolList(workspaceCommands)}
+
+## Como Guiar o Aluno
+
+- Instrua o aluno a rodar comandos no terminal
+- Leia a sa\xEDda dos comandos para orientar o pr\xF3ximo passo
+- Use \`tostudy hint\` antes de dar respostas diretas
+- Respeite a sequ\xEAncia dos m\xF3dulos
+
+## M\xF3dulos
+
+${formatModuleList(course.modules, course.currentModule)}
+
+---
+
+_ToStudy Platform \u2014 Criado por ${course.creator.name}_
+_Atualizado via \`tostudy sync\`_`;
+}
+function generateInstructions(course, options) {
+  if (options.mode === "cli") {
+    return generateCliContent(course);
+  }
+  return generateMcpContent(course);
+}
+
+// ../mcp-cli-core/src/render-for-ide.ts
+function getAgentsMdPath(scenario) {
+  return scenario === "existing" ? ".tostudy/AGENTS.md" : "AGENTS.md";
+}
+function renderCursorMdc(content) {
+  const title = content.match(/^# (.+)$/m)?.[1] ?? "ToStudy Course Guide";
+  return {
+    filePath: ".cursor/rules/tostudy.mdc",
+    content: `---
+description: ${title}
+globs: ["**/*"]
+alwaysApply: true
+---
+
+${content}`
+  };
+}
+function renderForIDE(content, ide, scenario) {
+  switch (ide) {
+    case "cursor":
+      return renderCursorMdc(content);
+    case "copilot":
+      return {
+        filePath: ".github/copilot-instructions.md",
+        content
+      };
+    case "claude-code":
+    case "codex":
+    case "vscode":
+    case "windsurf":
+    case "opencode":
+    case "antigravity":
+    case "manual":
+    default:
+      return {
+        filePath: getAgentsMdPath(scenario),
+        content
+      };
+  }
+}
+
+// src/commands/shared.ts
+var COURSE_ID_COMMENT_PREFIX = "<!-- tostudy-course-id:";
+var DEFAULT_AVAILABLE_TOOLS = [
+  { command: "start_module", description: "Carrega o pr\xF3ximo m\xF3dulo", category: "learning" },
+  { command: "next_lesson", description: "Avan\xE7a para a pr\xF3xima li\xE7\xE3o", category: "learning" },
+  { command: "get_hint", description: "Mostra dicas progressivas", category: "learning" },
+  { command: "validate_solution", description: "Valida o exerc\xEDcio atual", category: "learning" },
+  { command: "get_progress", description: "Mostra o progresso do curso", category: "learning" },
+  {
+    command: "setup_workspace",
+    description: "Configura o workspace do aluno",
+    category: "workspace"
+  }
+];
+function normalizeCourseContext(course) {
+  if ("availableTools" in course) {
+    return course;
+  }
+  return {
+    id: course.id,
+    title: course.title,
+    description: course.description ?? "",
+    modules: course.modules,
+    currentModule: course.currentModule,
+    currentLesson: course.currentLesson,
+    currentLessonTitle: course.currentLessonTitle,
+    progressPercent: course.progressPercent,
+    totalModules: course.totalModules || course.modules.length || 1,
+    creator: { name: course.creator.name },
+    availableTools: DEFAULT_AVAILABLE_TOOLS
+  };
+}
+async function fetchCourses(apiKey, platformUrl) {
+  try {
+    const baseUrl = platformUrl.replace(/\/$/, "");
+    const response = await fetch(`${baseUrl}/api/mcp/courses`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return [];
     }
-});
-// Install command - non-interactive, used by the web wizard's npx command
-const SUPPORTED_IDES = [
-    "claude-code",
-    "cursor",
-    "vscode",
-    "desktop",
-    "windsurf",
-    "opencode",
-    "codex",
-    "antigravity",
-    "manual",
+    const data = await response.json();
+    return (Array.isArray(data.courses) ? data.courses : []).map(
+      (course) => normalizeCourseContext(course)
+    );
+  } catch {
+    return [];
+  }
+}
+async function fetchCourseContext(courseId, apiKey, platformUrl) {
+  const courses = await fetchCourses(apiKey, platformUrl);
+  return courses.find((course) => course.id === courseId) ?? null;
+}
+async function detectInstructionMode(apiKey, platformUrl, verifyHeartbeat2) {
+  return await verifyHeartbeat2(apiKey, platformUrl) ? "mcp" : "cli";
+}
+function appendCourseMetadata(content, courseId) {
+  return `${content}
+
+${COURSE_ID_COMMENT_PREFIX} ${courseId} -->`;
+}
+function extractCourseId(content) {
+  const match = content.match(/<!-- tostudy-course-id:\s*([a-zA-Z0-9-_]+)\s*-->/);
+  return match?.[1] ?? null;
+}
+function inferInstructionTarget(filePath) {
+  if (filePath === ".cursor/rules/tostudy.mdc") {
+    return { ide: "cursor", scenario: "empty" };
+  }
+  if (filePath === ".github/copilot-instructions.md") {
+    return { ide: "copilot", scenario: "empty" };
+  }
+  if (filePath === ".tostudy/AGENTS.md") {
+    return { ide: "codex", scenario: "existing" };
+  }
+  return { ide: "manual", scenario: "empty" };
+}
+function resolveDetectedIde(ide) {
+  return ide?.id ?? "manual";
+}
+
+// src/commands/init.ts
+function println4(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+async function runInit(options, dependencies = {}) {
+  const cwd = dependencies.cwd ?? process.cwd();
+  const detectRunningIDE2 = dependencies.detectRunningIDE ?? detectRunningIDE;
+  const detectWorkspaceScenario2 = dependencies.detectWorkspaceScenario ?? detectWorkspaceScenario;
+  const verify = dependencies.verifyHeartbeat ?? verifyHeartbeat;
+  const fetchCourses2 = dependencies.fetchCourses ?? fetchCourses;
+  const fetchCourse = dependencies.fetchCourse ?? fetchCourseContext;
+  const promptForCourse = dependencies.promptForCourse ?? promptCourseSelection;
+  const confirmOverwrite = dependencies.confirmOverwrite ?? confirm;
+  let selectedCourseId = options.courseId;
+  let course = selectedCourseId ? await fetchCourse(selectedCourseId, options.apiKey, options.platformUrl) : null;
+  if (!selectedCourseId) {
+    const availableCourses = await fetchCourses2(options.apiKey, options.platformUrl);
+    if (availableCourses.length === 0) {
+      println4(
+        chalk4.yellow(
+          '  Nenhum curso MCP ativo encontrado. Use "--course <id>" ou configure um curso compat\xEDvel na plataforma.'
+        )
+      );
+      return { ok: false, reason: "course_required" };
+    }
+    if (availableCourses.length === 1) {
+      course = availableCourses[0] ?? null;
+      selectedCourseId = course?.id;
+      println4(chalk4.cyan(`  Curso selecionado automaticamente: ${course?.title}`));
+    } else {
+      const promptedCourseId = await promptForCourse(availableCourses);
+      if (!promptedCourseId) {
+        println4(chalk4.yellow("  Sele\xE7\xE3o de curso cancelada."));
+        return { ok: false, reason: "cancelled" };
+      }
+      selectedCourseId = promptedCourseId;
+      course = availableCourses.find((availableCourse) => availableCourse.id === selectedCourseId) ?? null;
+    }
+  }
+  const ide = await detectRunningIDE2();
+  const workspace = await detectWorkspaceScenario2(cwd);
+  const mode = await detectInstructionMode(options.apiKey, options.platformUrl, verify);
+  if (!course) {
+    println4(chalk4.red(`  N\xE3o foi poss\xEDvel carregar o curso ${selectedCourseId ?? "selecionado"}.`));
+    return { ok: false, reason: "course_not_found" };
+  }
+  const instructionContent = appendCourseMetadata(
+    generateInstructions(course, {
+      mode,
+      ide: resolveDetectedIde(ide),
+      locale: "pt-BR"
+    }),
+    course.id
+  );
+  const rendered = renderForIDE(instructionContent, resolveDetectedIde(ide), workspace.scenario);
+  const outputPath = join10(cwd, rendered.filePath);
+  if (existsSync13(outputPath)) {
+    const shouldOverwrite = await confirmOverwrite(
+      `  ${rendered.filePath} j\xE1 existe. Sobrescrever?`,
+      true
+    );
+    if (!shouldOverwrite) {
+      println4(chalk4.yellow("  Cancelado pelo usu\xE1rio."));
+      return { ok: false, reason: "cancelled" };
+    }
+  }
+  mkdirSync9(dirname9(outputPath), { recursive: true });
+  writeFileSync9(outputPath, rendered.content, "utf-8");
+  println4(chalk4.green(`  \u2713 Workspace configurado em ${rendered.filePath}`));
+  return {
+    ok: true,
+    outputPath,
+    mode,
+    courseId: course.id
+  };
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname10, join as join11 } from "path";
+import chalk5 from "chalk";
+function println5(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+var INSTRUCTION_CANDIDATES = [
+  "AGENTS.md",
+  ".tostudy/AGENTS.md",
+  ".cursor/rules/tostudy.mdc",
+  ".github/copilot-instructions.md"
 ];
-program
-    .command("install")
-    .description("Install MCP config for a specific IDE (used by the web setup wizard)")
-    .requiredOption("--ide <ide>", `Target IDE: ${SUPPORTED_IDES.join(", ")}`)
-    .requiredOption("--key <key>", "API key from the platform")
-    .option("--url <url>", "Platform URL (default: https://tostudy.ai)", DEFAULT_PLATFORM_URL)
-    .action(async (options) => {
+function findExistingInstruction(cwd) {
+  for (const candidate of INSTRUCTION_CANDIDATES) {
+    const fullPath = join11(cwd, candidate);
+    if (existsSync14(fullPath)) {
+      return {
+        relativePath: candidate,
+        content: readFileSync9(fullPath, "utf-8")
+      };
+    }
+  }
+  return null;
+}
+async function runSync(options, dependencies = {}) {
+  const cwd = dependencies.cwd ?? process.cwd();
+  const verify = dependencies.verifyHeartbeat ?? verifyHeartbeat;
+  const fetchCourse = dependencies.fetchCourse ?? fetchCourseContext;
+  const existing = findExistingInstruction(cwd);
+  if (!existing) {
+    println5(
+      chalk5.yellow('  Nenhum arquivo ToStudy encontrado. Rode "tostudy-mcp-setup init" primeiro.')
+    );
+    return { ok: false, reason: "instruction_missing" };
+  }
+  const courseId = options.courseId ?? extractCourseId(existing.content);
+  if (!courseId) {
+    println5(
+      chalk5.yellow(
+        '  Metadata do curso ausente. Rode "tostudy-mcp-setup init --course <id>" novamente.'
+      )
+    );
+    return { ok: false, reason: "course_metadata_missing" };
+  }
+  const mode = await detectInstructionMode(options.apiKey, options.platformUrl, verify);
+  const course = await fetchCourse(courseId, options.apiKey, options.platformUrl);
+  if (!course) {
+    println5(chalk5.red(`  N\xE3o foi poss\xEDvel sincronizar o curso ${courseId}.`));
+    return { ok: false, reason: "course_not_found" };
+  }
+  const target = inferInstructionTarget(existing.relativePath);
+  const instructionContent = appendCourseMetadata(
+    generateInstructions(course, {
+      mode,
+      ide: target.ide,
+      locale: "pt-BR"
+    }),
+    course.id
+  );
+  const rendered = renderForIDE(instructionContent, target.ide, target.scenario);
+  const outputPath = join11(cwd, rendered.filePath);
+  mkdirSync10(dirname10(outputPath), { recursive: true });
+  writeFileSync10(outputPath, rendered.content, "utf-8");
+  println5(chalk5.green(`  \u2713 ${rendered.filePath} sincronizado`));
+  return {
+    ok: true,
+    outputPath,
+    courseId: course.id,
+    mode
+  };
+}
+
+// src/index.ts
+var VERSION = "1.3.0";
+var DEFAULT_PLATFORM_URL2 = "https://tostudy.ai";
+var OAUTH_PORT = 9877;
+function println6(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function eprintln(message = "") {
+  process.stderr.write(`${message}
+`);
+}
+function printBanner() {
+  println6();
+  println6(chalk6.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  println6(
+    chalk6.cyan("  \u2551") + chalk6.white.bold("   ToStudy MCP Setup              ") + chalk6.cyan("\u2551")
+  );
+  println6(chalk6.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  println6();
+}
+async function validateApiKey(apiKey, platformUrl) {
+  try {
+    const response = await fetch(`${platformUrl}/api/mcp/heartbeat`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+    });
+    return response.ok || response.status === 204;
+  } catch {
+    println6(chalk6.yellow("! N\xE3o foi poss\xEDvel validar a API key (servidor offline?)"));
+    println6(chalk6.yellow("  A configura\xE7\xE3o ser\xE1 salva mesmo assim."));
+    return true;
+  }
+}
+async function exchangeCodeForToken(code, platformUrl, client = "mcp") {
+  const res = await fetch(`${platformUrl}/api/cli/auth/exchange`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code, client })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error ?? `Falha na autentica\xE7\xE3o (${res.status})`);
+  }
+  return res.json();
+}
+async function configureIDEs(token, platformUrl) {
+  const mcpUrl = resolveMcpServerUrl(platformUrl);
+  const allDetected = await detectInstalledIDEs();
+  const installedIDEs = allDetected.filter((h) => h.id !== "manual");
+  if (installedIDEs.length === 0) {
+    println6(chalk6.yellow("  Nenhuma IDE suportada detectada."));
+    println6(chalk6.gray("  Use: npx @tostudy-ai/mcp-setup install --ide <nome> --key <token>"));
+    return 0;
+  }
+  println6(chalk6.white("  IDEs detectadas:\n"));
+  for (let i = 0; i < installedIDEs.length; i++) {
+    println6(`    ${chalk6.cyan(String(i + 1))}. ${installedIDEs[i].name}`);
+  }
+  println6(`    ${chalk6.cyan("a")}. Todas`);
+  println6();
+  const answer = await prompt(
+    "  Quais configurar? (n\xFAmeros separados por v\xEDrgula, ou 'a' para todas) "
+  );
+  const trimmed = answer.trim().toLowerCase();
+  let selectedIDEs;
+  if (!trimmed || trimmed === "a" || trimmed === "all") {
+    selectedIDEs = installedIDEs;
+  } else {
+    const indices = trimmed.split(/[,\s]+/).map((s) => parseInt(s, 10) - 1).filter((i) => i >= 0 && i < installedIDEs.length);
+    if (indices.length === 0) {
+      println6(chalk6.yellow("  Nenhuma IDE selecionada."));
+      return 0;
+    }
+    selectedIDEs = indices.map((i) => installedIDEs[i]);
+  }
+  println6();
+  const claudeCodeHandler = selectedIDEs.find((h) => h.id === "claude-code");
+  let claudeCodeScope = "user";
+  if (claudeCodeHandler) {
+    claudeCodeScope = await promptClaudeCodeScope();
+    println6();
+  }
+  let configured = 0;
+  for (const handler of selectedIDEs) {
+    process.stdout.write(`  ${chalk6.gray("Configurando")} ${handler.name}... `);
     try {
-        const ide = options.ide;
-        if (!SUPPORTED_IDES.includes(ide)) {
-            eprintln(chalk.red(`Unknown IDE: ${ide}`));
-            eprintln(`Supported: ${SUPPORTED_IDES.join(", ")}`);
-            process.exit(1);
-        }
-        const handler = getIDEHandler(ide);
-        const mcpUrl = resolveMcpServerUrl(options.url);
-        println();
-        println(chalk.cyan(`  Installing MCP config for ${handler.name}...`));
-        // Write config
-        process.stdout.write(chalk.gray("  Writing config... "));
-        await handler.writeConfig(options.key, mcpUrl);
-        println(chalk.green("OK"));
-        if (ide !== "manual") {
-            println(chalk.gray(`  Config: ${handler.getConfigPath()}`));
-        }
-        // Verify heartbeat
-        process.stdout.write(chalk.gray("  Verifying connection... "));
-        const verified = await handler.verify(options.key, options.url);
-        if (verified) {
-            println(chalk.green("OK"));
-        }
-        else {
-            println(chalk.yellow("SKIPPED (server not reachable)"));
-            println(chalk.gray("  The config was saved. Connection will work when the server is available."));
+      if (handler.id === "claude-code") {
+        await writeClaudeCodeConfig(handler, token, mcpUrl, claudeCodeScope);
+      } else {
+        await handler.writeConfig(token, mcpUrl);
+      }
+      println6(chalk6.green("OK"));
+      configured++;
+    } catch (error) {
+      println6(chalk6.red("FALHOU"));
+      eprintln(chalk6.gray(`    ${error instanceof Error ? error.message : String(error)}`));
+    }
+  }
+  return configured;
+}
+async function writeClaudeCodeConfig(_handler, token, mcpUrl, scope) {
+  const { execFileSync: execFileSync5 } = await import("child_process");
+  const addArgs = buildClaudeCodeAddArgs(token, mcpUrl, scope);
+  const removeArgs = buildClaudeCodeRemoveArgs(scope);
+  try {
+    execFileSync5("claude", removeArgs, { stdio: "ignore" });
+  } catch {
+  }
+  execFileSync5("claude", addArgs, { stdio: "inherit" });
+}
+function printSuccessBanner(configuredCount) {
+  println6();
+  if (configuredCount > 0) {
+    println6(chalk6.green("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+    println6(
+      chalk6.green("  \u2551") + chalk6.white.bold(
+        `   ${configuredCount} IDE${configuredCount > 1 ? "s" : ""} configurada${configuredCount > 1 ? "s" : ""} com sucesso!`.padEnd(
+          42
+        )
+      ) + chalk6.green("\u2551")
+    );
+    println6(chalk6.green("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  } else {
+    println6(chalk6.yellow("  Nenhuma IDE foi configurada."));
+    println6(chalk6.gray("  Use: npx @tostudy-ai/mcp-setup install --ide <nome> --key <token>"));
+  }
+  println6();
+  println6(chalk6.white(NEXT_STEPS_TITLE));
+  println6(chalk6.gray("    1.") + " Reinicie as IDEs configuradas");
+  println6(chalk6.gray("    2.") + ASSISTANT_COURSES_PROMPT.trimStart());
+  println6();
+  println6(chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  println6();
+  println6(chalk6.white("  Prefere estudar pelo terminal?"));
+  println6(chalk6.gray("    ") + chalk6.cyan("npm install -g @tostudy-ai/cli"));
+  println6(
+    chalk6.gray("    ") + chalk6.cyan("tostudy login") + chalk6.gray(" \u2192 ") + chalk6.cyan("tostudy courses")
+  );
+  println6();
+}
+async function setup(apiKey, platformUrl) {
+  printBanner();
+  const url = platformUrl || process.env.TOSTUDY_PLATFORM_URL || DEFAULT_PLATFORM_URL2;
+  if (apiKey || process.env.TOSTUDY_API_KEY) {
+    const key = apiKey || process.env.TOSTUDY_API_KEY;
+    println6(chalk6.yellow(`  ${API_KEY_DEPRECATION_WARNING}`));
+    println6();
+    println6(chalk6.gray("  Usando API key fornecida..."));
+    process.stdout.write(chalk6.gray("  Validando... "));
+    const valid = await validateApiKey(key, url);
+    if (!valid) {
+      println6(chalk6.red("FALHOU"));
+      println6(chalk6.red("  API key inv\xE1lida ou expirada."));
+      process.exit(1);
+    }
+    println6(chalk6.green("OK"));
+    println6();
+    const configured2 = await configureIDEs(key, url);
+    printSuccessBanner(configured2);
+    return;
+  }
+  println6(chalk6.gray("  Abrindo browser para autentica\xE7\xE3o...\n"));
+  let code;
+  try {
+    const serverPromise = startCallbackServer(OAUTH_PORT);
+    const authUrl = `${url}/api/cli/auth/authorize?port=${OAUTH_PORT}`;
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    const openArgs = process.platform === "win32" ? ["", authUrl] : [authUrl];
+    execFile(openCmd, openArgs, (err) => {
+      if (err) {
+        println6(chalk6.yellow("  N\xE3o foi poss\xEDvel abrir o browser automaticamente."));
+        println6(chalk6.gray(`  Abra manualmente: ${authUrl}
+`));
+      }
+    });
+    const result = await serverPromise;
+    code = result.code;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    eprintln(chalk6.red(`  Erro: ${msg}`));
+    process.exit(1);
+  }
+  process.stdout.write(chalk6.gray("  Autenticando... "));
+  let token;
+  let userName;
+  try {
+    const result = await exchangeCodeForToken(code, url, "mcp");
+    token = result.token;
+    userName = result.userName;
+    println6(chalk6.green("OK"));
+    println6(chalk6.green(`  Logado como ${userName}
+`));
+  } catch (err) {
+    println6(chalk6.red("FALHOU"));
+    eprintln(chalk6.red(`  ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  println6(chalk6.gray("  Detectando IDEs...\n"));
+  const configured = await configureIDEs(token, url);
+  printSuccessBanner(configured);
+}
+async function uninstall() {
+  printBanner();
+  if (!isTostudyMcpConfigured()) {
+    println6(chalk6.yellow("ToStudy MCP n\xE3o est\xE1 configurado."));
+    process.exit(0);
+  }
+  const shouldUninstall = await confirm("Remover configura\xE7\xE3o do ToStudy MCP?", false);
+  if (!shouldUninstall) {
+    println6(chalk6.gray("Opera\xE7\xE3o cancelada."));
+    process.exit(0);
+  }
+  process.stdout.write(chalk6.gray("Removendo configura\xE7\xE3o... "));
+  try {
+    removeTostudyMcpServer();
+    println6(chalk6.green("OK"));
+    println6();
+    println6(chalk6.green("Configura\xE7\xE3o removida com sucesso."));
+    println6(chalk6.gray("Reinicie o Claude Code para aplicar as mudan\xE7as."));
+    println6();
+  } catch (error) {
+    println6(chalk6.red("FALHOU"));
+    eprintln(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function printStep(step, total, title) {
+  println6();
+  println6(chalk6.cyan(`\u2501\u2501\u2501 Passo ${step}/${total}: ${title} \u2501\u2501\u2501`));
+  println6();
+}
+function printIDEDetection(installedIDEs) {
+  if (installedIDEs.length === 0) {
+    println6(chalk6.yellow("  Nenhuma IDE suportada detectada."));
+    println6(chalk6.gray("  O setup continuar\xE1 para Claude Code."));
+  } else {
+    println6(chalk6.green("  IDEs detectadas:"));
+    for (const ide of installedIDEs) {
+      const version = ide.version ? chalk6.gray(` (${ide.version})`) : "";
+      println6(`    ${chalk6.green("\u2713")} ${ide.name}${version}`);
+    }
+  }
+}
+async function wizard(options) {
+  const TOTAL_STEPS = 4;
+  println6();
+  println6(chalk6.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  println6(
+    chalk6.cyan("  \u2551") + chalk6.white.bold("   ToStudy MCP Setup Wizard               ") + chalk6.cyan("\u2551")
+  );
+  println6(
+    chalk6.cyan("  \u2551") + chalk6.gray("   Configura\xE7\xE3o guiada passo a passo       ") + chalk6.cyan("\u2551")
+  );
+  println6(chalk6.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  println6();
+  println6(chalk6.gray("  Este assistente vai configurar o Claude Code para"));
+  println6(chalk6.gray("  conectar ao servidor MCP da plataforma ToStudy."));
+  println6();
+  printStep(1, TOTAL_STEPS, "Detectando ambiente");
+  process.stdout.write("  Verificando Claude Code... ");
+  if (!isClaudeInstalled()) {
+    println6(chalk6.red("N\xC3O ENCONTRADO"));
+    println6();
+    println6(chalk6.red("  Claude Code n\xE3o est\xE1 instalado."));
+    println6();
+    println6("  Por favor, instale primeiro:");
+    println6(chalk6.cyan("    https://claude.ai/download"));
+    println6();
+    process.exit(1);
+  }
+  println6(chalk6.green("OK"));
+  const configPath = getClaudeConfigPath();
+  println6(chalk6.gray(`    Config: ${configPath}`));
+  process.stdout.write("  Detectando IDEs... ");
+  const installedIDEs = getInstalledIDEs();
+  println6(chalk6.green("OK"));
+  printIDEDetection(installedIDEs);
+  process.stdout.write("  Verificando configura\xE7\xE3o atual... ");
+  const alreadyConfigured = isTostudyMcpConfigured();
+  if (alreadyConfigured) {
+    println6(chalk6.yellow("J\xC1 CONFIGURADO"));
+    println6();
+    const overwrite = await confirm("  Deseja reconfigurar?", false);
+    if (!overwrite) {
+      println6();
+      println6(chalk6.gray("  Opera\xE7\xE3o cancelada."));
+      process.exit(0);
+    }
+  } else {
+    println6(chalk6.gray("N\xE3o configurado"));
+  }
+  printStep(2, TOTAL_STEPS, "Configurando API Key");
+  println6(chalk6.gray("  A API key conecta o Claude Code a sua conta na plataforma."));
+  println6();
+  let apiKey = options.apiKey || process.env.TOSTUDY_API_KEY;
+  if (!apiKey) {
+    println6("  Acesse sua API key em:");
+    println6(chalk6.cyan(`    ${options.url || DEFAULT_PLATFORM_URL2}/student/settings/mcp`));
+    println6();
+    apiKey = await promptApiKey();
+  } else {
+    println6(chalk6.yellow(`  ${API_KEY_DEPRECATION_WARNING}`));
+    println6();
+    println6(chalk6.green("  \u2713 API key fornecida via par\xE2metro ou ambiente"));
+  }
+  const platformUrl = options.url || process.env.TOSTUDY_PLATFORM_URL || DEFAULT_PLATFORM_URL2;
+  println6();
+  process.stdout.write(chalk6.gray("  Validando API key... "));
+  const valid = await validateApiKey(apiKey, platformUrl);
+  if (!valid) {
+    println6(chalk6.red("FALHOU"));
+    println6();
+    println6(chalk6.red("  API key inv\xE1lida ou expirada."));
+    println6();
+    println6("  Para gerar uma nova API key:");
+    println6(chalk6.cyan(`    ${platformUrl}/student/settings/mcp`));
+    println6();
+    process.exit(1);
+  }
+  println6(chalk6.green("OK"));
+  printStep(3, TOTAL_STEPS, "Salvando configura\xE7\xE3o");
+  process.stdout.write("  Configurando Claude Code... ");
+  try {
+    addTostudyMcpServer(apiKey, platformUrl);
+    println6(chalk6.green("OK"));
+  } catch (error) {
+    println6(chalk6.red("FALHOU"));
+    eprintln();
+    eprintln(chalk6.red("  Erro ao salvar configura\xE7\xE3o:"));
+    eprintln("  " + (error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  printStep(4, TOTAL_STEPS, "Verifica\xE7\xE3o final");
+  if (!options.skipDiagnostics) {
+    process.stdout.write("  Executando diagn\xF3stico... ");
+    const report = await runDiagnostics();
+    println6(chalk6.green("OK"));
+    println6();
+    const remainingIssues = report.issues.filter(
+      (issue) => !["mcp-not-configured", "config-missing"].includes(issue.id)
+    );
+    if (remainingIssues.length > 0) {
+      println6(chalk6.yellow("  Avisos encontrados:"));
+      for (const issue of remainingIssues) {
+        const icon = issue.severity === "critical" ? chalk6.red("\u25CF") : issue.severity === "warning" ? chalk6.yellow("\u25CF") : chalk6.blue("\u25CF");
+        println6(`    ${icon} ${issue.title}`);
+      }
+      println6();
+      if (options.autoRepair) {
+        process.stdout.write("  Tentando reparar automaticamente... ");
+        const repairReport = repairAllIssues(report, apiKey, platformUrl);
+        if (repairReport.repairsSucceeded > 0) {
+          println6(chalk6.green(`${repairReport.repairsSucceeded} corrigido(s)`));
+        } else {
+          println6(chalk6.yellow("Nenhum reparo aplicado"));
         }
-        println();
-        println(chalk.green.bold("  Done! Restart your IDE to activate the MCP server."));
-        println();
+      } else {
+        println6(
+          chalk6.gray('  Dica: Execute "npx @tostudy-ai/mcp-setup diagnose" para mais detalhes.')
+        );
+      }
+    } else {
+      println6(chalk6.green("  \u2713 Nenhum problema encontrado!"));
     }
-    catch (error) {
-        eprintln();
-        eprintln(chalk.red("Install failed:") +
-            " " +
-            (error instanceof Error ? error.message : String(error)));
-        process.exit(1);
+  } else {
+    println6(chalk6.gray("  Diagn\xF3stico ignorado (--skip-diagnostics)"));
+  }
+  println6();
+  println6(chalk6.green("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  println6(
+    chalk6.green("  \u2551") + chalk6.white.bold("   Configura\xE7\xE3o conclu\xEDda com sucesso!     ") + chalk6.green("\u2551")
+  );
+  println6(chalk6.green("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  println6();
+  println6(chalk6.white(NEXT_STEPS_TITLE));
+  println6();
+  println6(chalk6.gray("    1.") + " Reinicie o Claude Code");
+  println6(chalk6.gray("    2.") + " O servidor MCP iniciar\xE1 automaticamente");
+  println6(chalk6.gray("    3.") + COURSES_TOOL_HINT.trimStart());
+  println6();
+  println6(chalk6.gray("  Comandos \xFAteis:"));
+  println6(
+    chalk6.gray("    ") + chalk6.cyan("npx @tostudy-ai/mcp-setup diagnose") + chalk6.gray(" - Verificar problemas")
+  );
+  println6(
+    chalk6.gray("    ") + chalk6.cyan("npx @tostudy-ai/mcp-setup repair") + chalk6.gray("   - Reparar automaticamente")
+  );
+  println6();
+  println6(chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  println6();
+  println6(chalk6.white("  Prefere estudar pelo terminal?"));
+  println6(chalk6.gray("    ") + chalk6.cyan("npm install -g @tostudy-ai/cli"));
+  println6(
+    chalk6.gray("    ") + chalk6.cyan("tostudy login") + chalk6.gray(" \u2192 ") + chalk6.cyan("tostudy courses")
+  );
+  println6();
+}
+program.name("tostudy-mcp-setup").description("Configura o Claude Code para usar o ToStudy MCP server").version(VERSION);
+program.option("-k, --api-key <key>", "(deprecated) API key \u2014 use OAuth flow instead").option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)").option("--uninstall", "Remove a configura\xE7\xE3o do ToStudy MCP").action(async (options) => {
+  try {
+    if (options.uninstall) {
+      await uninstall();
+    } else {
+      await setup(options.apiKey, options.url);
     }
+  } catch (error) {
+    eprintln();
+    eprintln(chalk6.red("Erro:") + " " + (error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
 });
-/**
- * Resolve the MCP server URL from the platform URL.
- * The platform runs on port 3700, MCP server on 3701.
- */
-function resolveMcpServerUrl(platformUrl) {
-    if (platformUrl.includes(":3700")) {
-        return platformUrl.replace(":3700", ":3701");
+program.command("wizard").description("Assistente interativo de configura\xE7\xE3o passo a passo").option("-k, --api-key <key>", "(deprecated) API key \u2014 use OAuth flow instead").option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)").option("--skip-diagnostics", "Pula a verifica\xE7\xE3o de diagn\xF3stico ap\xF3s setup").option("--auto-repair", "Tenta reparar problemas automaticamente").action(async (options) => {
+  try {
+    await wizard({
+      apiKey: options.apiKey,
+      url: options.url,
+      skipDiagnostics: options.skipDiagnostics,
+      autoRepair: options.autoRepair
+    });
+  } catch (error) {
+    eprintln();
+    eprintln(chalk6.red("Erro:") + " " + (error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+program.command("diagnose").description("Executa diagn\xF3stico de problemas na configura\xE7\xE3o MCP").option("--json", "Sa\xEDda em formato JSON").action(async (options) => {
+  try {
+    const report = await runDiagnostics();
+    if (options.json) {
+      println6(JSON.stringify(report, null, 2));
+    } else {
+      printDiagnosticReport(report);
     }
-    if (platformUrl.includes("localhost") && !platformUrl.includes(":")) {
-        return "http://localhost:3701";
+    process.exit(report.passed ? 0 : 1);
+  } catch (error) {
+    eprintln();
+    eprintln(chalk6.red("Erro ao executar diagn\xF3stico:"));
+    eprintln(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("repair").description("Repara problemas de configura\xE7\xE3o automaticamente").option("-k, --api-key <key>", "API key para reparos que necessitam autentica\xE7\xE3o").option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)").option("--json", "Sa\xEDda em formato JSON").action(async (options) => {
+  try {
+    const apiKey = options.apiKey || process.env.TOSTUDY_API_KEY;
+    const platformUrl = options.url || DEFAULT_PLATFORM_URL2;
+    const diagnostic = await runDiagnostics();
+    const repair = repairAllIssues(diagnostic, apiKey, platformUrl);
+    if (options.json) {
+      println6(JSON.stringify({ diagnostic, repair }, null, 2));
+    } else {
+      printRepairReport(repair);
+    }
+    const hasUnfixedCritical = diagnostic.issues.some(
+      (issue) => issue.severity === "critical" && !repair.results.find((r) => r.issueId === issue.id && r.success)
+    );
+    process.exit(hasUnfixedCritical ? 1 : 0);
+  } catch (error) {
+    eprintln();
+    eprintln(chalk6.red("Erro ao executar reparo:"));
+    eprintln(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var SUPPORTED_IDES = [
+  "claude-code",
+  "cursor",
+  "vscode",
+  "desktop",
+  "windsurf",
+  "opencode",
+  "codex",
+  "antigravity",
+  "manual"
+];
+program.command("install").description("Install MCP config for a specific IDE (used by the web setup wizard)").requiredOption("--ide <ide>", `Target IDE: ${SUPPORTED_IDES.join(", ")}`).requiredOption("--key <key>", "API key from the platform").option("--url <url>", "Platform URL (default: https://tostudy.ai)", DEFAULT_PLATFORM_URL2).action(async (options) => {
+  try {
+    const ide = options.ide;
+    if (!SUPPORTED_IDES.includes(ide)) {
+      eprintln(chalk6.red(`Unknown IDE: ${ide}`));
+      eprintln(`Supported: ${SUPPORTED_IDES.join(", ")}`);
+      process.exit(1);
     }
-    // Production: use dedicated MCP subdomain
-    if (platformUrl.includes("tostudy")) {
-        return process.env.MCP_SERVER_URL || "https://mcp.tostudy.ai";
+    const handler = getIDEHandler(ide);
+    const mcpUrl = resolveMcpServerUrl(options.url);
+    println6();
+    println6(chalk6.cyan(`  Installing MCP config for ${handler.name}...`));
+    process.stdout.write(chalk6.gray("  Writing config... "));
+    await handler.writeConfig(options.key, mcpUrl);
+    println6(chalk6.green("OK"));
+    if (ide !== "manual") {
+      println6(chalk6.gray(`  Config: ${handler.getConfigPath()}`));
     }
-    return platformUrl;
+    process.stdout.write(chalk6.gray("  Verifying connection... "));
+    const verified = await handler.verify(options.key, options.url);
+    if (verified) {
+      println6(chalk6.green("OK"));
+    } else {
+      println6(chalk6.yellow("SKIPPED (server not reachable)"));
+      println6(
+        chalk6.gray("  The config was saved. Connection will work when the server is available.")
+      );
+    }
+    println6();
+    println6(chalk6.green.bold("  Done! Restart your IDE to activate the MCP server."));
+    println6();
+  } catch (error) {
+    eprintln();
+    eprintln(
+      chalk6.red("Install failed:") + " " + (error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+});
+function resolveMcpServerUrl(platformUrl) {
+  if (platformUrl.includes(":3700")) {
+    return platformUrl.replace(":3700", ":3701");
+  }
+  if (platformUrl.includes("localhost") && !platformUrl.includes(":")) {
+    return "http://localhost:3701";
+  }
+  if (platformUrl.includes("tostudy")) {
+    return process.env.MCP_SERVER_URL || "https://mcp.tostudy.ai";
+  }
+  return platformUrl;
+}
+function resolvePlatformUrl(explicitUrl) {
+  return explicitUrl || process.env.TOSTUDY_PLATFORM_URL || DEFAULT_PLATFORM_URL2;
 }
+async function resolveCommandApiKey(explicitApiKey) {
+  const apiKey = explicitApiKey || process.env.TOSTUDY_API_KEY;
+  if (apiKey) {
+    return apiKey;
+  }
+  return promptApiKey();
+}
+program.command("init").description("Configura instru\xE7\xF5es do curso no workspace atual").requiredOption("--course <courseId>", "Course ID to configure in this workspace").option("-k, --api-key <key>", "API key para autentica\xE7\xE3o").option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)").action(async (options) => {
+  try {
+    const result = await runInit({
+      apiKey: await resolveCommandApiKey(options.apiKey),
+      platformUrl: resolvePlatformUrl(options.url),
+      courseId: options.course
+    });
+    if (!result.ok) {
+      process.exit(1);
+    }
+  } catch (error) {
+    eprintln();
+    eprintln(
+      chalk6.red("Erro no init:") + " " + (error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+});
+program.command("sync").description("Regenera as instru\xE7\xF5es do curso com base no arquivo existente").option("--course <courseId>", "Course ID override when metadata is unavailable").option("-k, --api-key <key>", "API key para autentica\xE7\xE3o").option("-u, --url <url>", "URL da plataforma (default: https://tostudy.ai)").action(async (options) => {
+  try {
+    const result = await runSync({
+      apiKey: await resolveCommandApiKey(options.apiKey),
+      platformUrl: resolvePlatformUrl(options.url),
+      courseId: options.course
+    });
+    if (!result.ok) {
+      process.exit(1);
+    }
+  } catch (error) {
+    eprintln();
+    eprintln(
+      chalk6.red("Erro no sync:") + " " + (error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map