@edilsonfjdev/mcp-setup 0.1.0

package/dist/doctor-OBFIE3JN.js

@@ -0,0 +1,161 @@
+import {
+  getRequiredVars,
+  loadEnv,
+  validateAllCredentials,
+  validatePresence
+} from "./chunk-JNVJQZTK.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/utils/preflight.ts
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCb);
+async function checkNodeVersion() {
+  const version = process.versions.node;
+  const major = parseInt(version.split(".")[0]);
+  if (major >= 18) {
+    return { check: "Node.js", status: "ok", message: `v${version}` };
+  }
+  return {
+    check: "Node.js",
+    status: "fail",
+    message: `Node.js >= 18 \xE9 necess\xE1rio. Vers\xE3o atual: v${version}`
+  };
+}
+async function checkClaudeCli() {
+  try {
+    const { stdout } = await exec("claude --version");
+    return { check: "Claude Code", status: "ok", message: stdout.trim() };
+  } catch {
+    return {
+      check: "Claude Code",
+      status: "fail",
+      message: "Claude Code n\xE3o encontrado. Instale em: https://claude.ai/code"
+    };
+  }
+}
+async function runPreflight() {
+  return Promise.all([
+    checkNodeVersion(),
+    checkClaudeCli()
+  ]);
+}
+
+// src/utils/gitignore-audit.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function auditGitignore(projectPath) {
+  const basePath = projectPath || process.cwd();
+  const gitignorePath = resolve(basePath, ".gitignore");
+  const results = [];
+  if (!existsSync(gitignorePath)) {
+    results.push({
+      status: "error",
+      message: "Arquivo .gitignore n\xE3o encontrado no projeto",
+      suggestion: "Crie um .gitignore: touch .gitignore"
+    });
+    return results;
+  }
+  const content = readFileSync(gitignorePath, "utf-8");
+  const lines = content.split("\n").map((l) => l.trim());
+  if (!lines.includes(".env")) {
+    results.push({
+      status: "warning",
+      message: ".env N\xC3O est\xE1 no .gitignore \u2014 risco de commit de credenciais",
+      suggestion: "echo '.env' >> .gitignore"
+    });
+  } else {
+    results.push({
+      status: "ok",
+      message: ".env est\xE1 protegido no .gitignore"
+    });
+  }
+  if (!lines.some((l) => l === ".env.local" || l === ".env.*" || l === ".env.*.local")) {
+    results.push({
+      status: "warning",
+      message: ".env.local n\xE3o est\xE1 explicitamente no .gitignore",
+      suggestion: "echo '.env.local' >> .gitignore"
+    });
+  }
+  if (!lines.some((l) => l === ".claude.json")) {
+    results.push({
+      status: "warning",
+      message: ".claude.json n\xE3o est\xE1 no .gitignore \u2014 pode conter tokens",
+      suggestion: "echo '.claude.json' >> .gitignore"
+    });
+  }
+  return results;
+}
+
+// src/commands/doctor.ts
+import chalk from "chalk";
+async function doctorCommand() {
+  logger.info("Diagn\xF3stico do ambiente MCP Setup\n");
+  let hasErrors = false;
+  logger.info("Pr\xE9-requisitos:");
+  const preflight = await runPreflight();
+  for (const check of preflight) {
+    if (check.status === "ok") {
+      console.log(chalk.green(`  \u2713 ${check.check}: ${check.message}`));
+    } else {
+      console.log(chalk.red(`  \u2717 ${check.check}: ${check.message}`));
+      hasErrors = true;
+    }
+  }
+  console.log("");
+  logger.info("Seguran\xE7a:");
+  const gitAudit = auditGitignore();
+  for (const result of gitAudit) {
+    if (result.status === "ok") {
+      console.log(chalk.green(`  \u2713 ${result.message}`));
+    } else if (result.status === "warning") {
+      console.log(chalk.yellow(`  ! ${result.message}`));
+      if (result.suggestion) console.log(chalk.gray(`    \u2192 ${result.suggestion}`));
+    } else {
+      console.log(chalk.red(`  \u2717 ${result.message}`));
+      if (result.suggestion) console.log(chalk.gray(`    \u2192 ${result.suggestion}`));
+      hasErrors = true;
+    }
+  }
+  console.log("");
+  logger.info("Configura\xE7\xE3o:");
+  const envResult = loadEnv();
+  if (envResult.success) {
+    console.log(chalk.green(`  \u2713 Arquivo .env encontrado: ${envResult.path}`));
+    const required = getRequiredVars("base");
+    const presence = validatePresence(envResult.vars, required);
+    if (presence.valid) {
+      console.log(chalk.green(`  \u2713 Todas as credenciais do template "base" presentes (${presence.present.length}/${required.length})`));
+    } else {
+      console.log(chalk.yellow(`  ! Credenciais faltando para template "base": ${presence.missing.length}`));
+      for (const m of presence.missing) {
+        console.log(chalk.yellow(`    - ${m.name}: ${m.description}`));
+      }
+    }
+    const validations = validateAllCredentials("base", envResult.vars);
+    const formatErrors = validations.filter((v) => !v.valid && presence.present.includes(v.variable));
+    if (formatErrors.length > 0) {
+      console.log(chalk.yellow(`  ! ${formatErrors.length} credencial(is) com formato inv\xE1lido:`));
+      for (const f of formatErrors) {
+        console.log(chalk.yellow(`    - ${f.variable}: ${f.error}`));
+      }
+    } else if (presence.present.length > 0) {
+      console.log(chalk.green(`  \u2713 Formato das credenciais v\xE1lido`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ! ${envResult.error}`));
+    console.log(chalk.gray("    \u2192 cp .env.example .env"));
+  }
+  console.log("");
+  if (hasErrors) {
+    logger.error("Problemas encontrados \u2014 corrija os itens acima");
+    process.exit(1);
+  } else {
+    logger.success("Ambiente saud\xE1vel \u2014 pronto para usar mcp-setup");
+  }
+}
+export {
+  doctorCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,42 @@
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var cli = new Command();
+cli.name("mcp-setup").description("Instala\xE7\xE3o e configura\xE7\xE3o de MCP Servers para Claude Code").version(pkg.version).option("--verbose", "Sa\xEDda detalhada com informa\xE7\xF5es de debug").option("--no-color", "Desativar cores no output").option("--yes", "Pular confirma\xE7\xF5es interativas");
+cli.command("install").description("Instala MCPs de um template pr\xE9-definido").requiredOption("-t, --template <nome>", "Template a instalar (minimal, base, saas, agents, full)").option("-s, --scope <escopo>", "Escopo de instala\xE7\xE3o (user, project, local)", "user").option("--add <mcps...>", "MCPs adicionais para incluir").option("--remove <mcps...>", "MCPs para excluir do template").option("--dry-run", "Simular instala\xE7\xE3o sem executar").option("--skip-oauth", "Ignorar MCPs que exigem OAuth (para ambientes headless/VPS)").action(async (options) => {
+  const { installCommand } = await import("./install-DAWHBGCE.js");
+  await installCommand(options);
+});
+cli.command("validate").description("Valida credenciais e configura\xE7\xE3o do ambiente").option("--health", "Testar conectividade real com cada MCP").action(async (options) => {
+  const { validateCommand } = await import("./validate-6RKOV7JG.js");
+  await validateCommand(options);
+});
+cli.command("list").description("Lista MCPs configurados no ambiente").option("-s, --scope <escopo>", "Filtrar por escopo (user, project, local)").action(async (options) => {
+  const { listCommand } = await import("./list-QO4GBJHR.js");
+  await listCommand(options);
+});
+cli.command("add <mcp>").description("Adiciona um MCP individual").option("-s, --scope <escopo>", "Escopo de instala\xE7\xE3o (user, project, local)", "user").option("--dry-run", "Simular sem executar").action(async (mcp, options) => {
+  const { addCommand } = await import("./add-2HOZTV5H.js");
+  await addCommand(mcp, options);
+});
+cli.command("remove <mcp>").description("Remove um MCP configurado").option("-s, --scope <escopo>", "Escopo de remo\xE7\xE3o").option("--yes", "Pular confirma\xE7\xE3o").action(async (mcp, options) => {
+  const { removeCommand } = await import("./remove-T6C2DD7O.js");
+  await removeCommand(mcp, options);
+});
+cli.command("update [mcp]").description("Atualiza MCPs para a configura\xE7\xE3o mais recente").option("--all", "Atualizar todos os MCPs instalados").option("--dry-run", "Simular sem executar").action(async (mcp, options) => {
+  const { updateCommand } = await import("./update-GOCA4IZG.js");
+  await updateCommand(mcp, options);
+});
+cli.command("doctor").description("Diagn\xF3stico completo do ambiente MCP").action(async () => {
+  const { doctorCommand } = await import("./doctor-OBFIE3JN.js");
+  await doctorCommand();
+});
+cli.command("profiles").description("Lista profiles/templates dispon\xEDveis").option("--verbose", "Mostrar MCPs de cada profile").action(async (options) => {
+  const { profilesCommand } = await import("./profiles-HU3NVRTV.js");
+  await profilesCommand(options);
+});
+
+// src/index.ts
+cli.parse(process.argv);

package/dist/install-DAWHBGCE.js

@@ -0,0 +1,169 @@
+import {
+  loadEnv,
+  validateAllCredentials
+} from "./chunk-JNVJQZTK.js";
+import {
+  applyHeadlessMode,
+  executeCommands,
+  filterAlreadyInstalled,
+  generateCommands,
+  getInstalledMcps,
+  resolveScopesForProfile
+} from "./chunk-H3PELLAE.js";
+import {
+  loadMcp,
+  loadProfile
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/core/template-composer.ts
+function resolveMcpList(profile, options) {
+  let mcpList = [...profile.mcps];
+  if (profile.extends) {
+    const parent = loadProfile(profile.extends);
+    mcpList = [...parent.mcps];
+    if (profile.add) {
+      for (const mcp of profile.add) {
+        if (!mcpList.includes(mcp)) mcpList.push(mcp);
+      }
+    }
+    if (profile.remove) {
+      mcpList = mcpList.filter((m) => !profile.remove.includes(m));
+    }
+  }
+  if (options?.add) {
+    for (const mcp of options.add) {
+      if (!mcpList.includes(mcp)) mcpList.push(mcp);
+    }
+  }
+  if (options?.remove) {
+    mcpList = mcpList.filter((m) => !options.remove.includes(m));
+  }
+  return mcpList;
+}
+function getProfileMcps(profileName, options) {
+  const profile = loadProfile(profileName);
+  const mcpList = resolveMcpList(profile, options);
+  return mcpList.map((name) => loadMcp(name));
+}
+
+// src/commands/install.ts
+async function installCommand(options) {
+  const { template, scope, add, remove, dryRun, skipOauth } = options;
+  logger.info(`Instalando MCPs do template "${template}"...`);
+  if (dryRun) logger.warn("Modo dry-run: nenhuma altera\xE7\xE3o ser\xE1 feita");
+  if (skipOauth) logger.info("Modo headless: MCPs OAuth ser\xE3o configurados via token/API key");
+  let mcps;
+  try {
+    mcps = getProfileMcps(template, { add, remove });
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+  logger.info(`${mcps.length} MCPs resolvidos para o template "${template}"`);
+  let oauthSkipped = [];
+  if (skipOauth) {
+    const headless = applyHeadlessMode(mcps);
+    mcps = headless.resolved;
+    oauthSkipped = headless.skipped;
+    const converted = mcps.filter((m) => m.auth.type === "api-key" || m.auth.type === "bearer");
+    if (converted.length > 0) {
+      logger.success(`${converted.length} MCP(s) OAuth convertido(s) para modo headless: ${converted.map((m) => m.name).join(", ")}`);
+    }
+    if (oauthSkipped.length > 0) {
+      logger.warn(`${oauthSkipped.length} MCP(s) sem alternativa headless: ${oauthSkipped.map((m) => m.name).join(", ")}`);
+    }
+  }
+  const spinner1 = logger.spinner("Verificando MCPs j\xE1 instalados...");
+  const installed = await getInstalledMcps();
+  spinner1.stop();
+  const { pending, existing } = filterAlreadyInstalled(mcps, installed);
+  if (existing.length > 0) {
+    logger.info(`${existing.length} MCP(s) j\xE1 instalado(s): ${existing.map((m) => m.name).join(", ")}`);
+  }
+  if (pending.length === 0) {
+    logger.success("Todos os MCPs do template j\xE1 est\xE3o configurados!");
+    return;
+  }
+  logger.info(`${pending.length} MCP(s) pendente(s) para instala\xE7\xE3o`);
+  const envResult = loadEnv();
+  if (envResult.success) {
+    const validations = validateAllCredentials(template, envResult.vars);
+    const failures = validations.filter((v) => !v.valid);
+    const pendingNameSet = new Set(pending.map((m) => m.name));
+    const relevantFailures = failures.filter((f) => {
+      const mcp = pending.find((m) => m.auth.envVar === f.variable);
+      return mcp && pendingNameSet.has(mcp.name);
+    });
+    if (relevantFailures.length > 0) {
+      logger.warn(`${relevantFailures.length} credencial(is) com problema:`);
+      for (const f of relevantFailures) {
+        logger.warn(`  ${f.variable}: ${f.error}`);
+      }
+      const criticalFailures = relevantFailures.filter((f) => {
+        const mcp = pending.find((m) => m.auth.envVar === f.variable);
+        return mcp && mcp.auth.type !== "oauth" && mcp.auth.type !== "none";
+      });
+      if (criticalFailures.length > 0 && !dryRun) {
+        logger.error("Corrija as credenciais acima antes de instalar. Consulte .env.example.");
+        process.exit(1);
+      }
+    } else {
+      logger.success("Credenciais validadas para MCPs pendentes");
+    }
+  } else {
+    logger.warn(envResult.error || "Arquivo .env n\xE3o encontrado");
+    if (!dryRun) {
+      logger.warn("Prosseguindo sem valida\xE7\xE3o de credenciais...");
+    }
+  }
+  const pendingNames = pending.map((m) => m.name);
+  const scopes = resolveScopesForProfile(pendingNames, scope);
+  const commands = generateCommands(pending, scopes);
+  if (dryRun) {
+    logger.info("\nComandos que seriam executados:\n");
+    for (const cmd of commands) {
+      console.log(`  [${cmd.scope}] ${cmd.command}`);
+    }
+    console.log("");
+    if (existing.length > 0) logger.info(`${existing.length} j\xE1 instalado(s) (sem a\xE7\xE3o)`);
+    if (oauthSkipped.length > 0) logger.warn(`${oauthSkipped.length} sem alternativa headless: ${oauthSkipped.map((m) => m.name).join(", ")}`);
+    logger.info(`${pending.length} seria(m) instalado(s)`);
+    return;
+  }
+  const spinner2 = logger.spinner(`Instalando ${commands.length} MCPs...`);
+  const results = await executeCommands(commands, false);
+  spinner2.stop();
+  const success = results.filter((r) => r.success && !r.skipped);
+  const skipped = results.filter((r) => r.skipped);
+  const failed = results.filter((r) => !r.success);
+  console.log("");
+  if (existing.length > 0) {
+    logger.info(`${existing.length} MCP(s) j\xE1 configurado(s) (sem a\xE7\xE3o)`);
+    for (const m of existing) console.log(`    ${m.name}`);
+  }
+  if (success.length > 0) {
+    logger.success(`${success.length} MCP(s) instalado(s) com sucesso`);
+    for (const r of success) console.log(`    ${r.mcpName}: ${r.message}`);
+  }
+  if (skipped.length > 0) {
+    logger.info(`${skipped.length} MCP(s) ignorado(s) na execu\xE7\xE3o`);
+    for (const r of skipped) console.log(`    ${r.mcpName}`);
+  }
+  if (oauthSkipped.length > 0) {
+    logger.warn(`${oauthSkipped.length} MCP(s) sem alternativa headless (apenas Figma)`);
+    for (const m of oauthSkipped) console.log(`    ${m.name} \u2014 requer browser para OAuth`);
+  }
+  if (failed.length > 0) {
+    logger.error(`${failed.length} MCP(s) falharam na instala\xE7\xE3o`);
+    for (const r of failed) console.log(`    ${r.mcpName}: ${r.message}`);
+    process.exit(1);
+  }
+  console.log("");
+  logger.success(`Template "${template}" instalado com sucesso!`);
+}
+export {
+  installCommand
+};

package/dist/list-QO4GBJHR.js

@@ -0,0 +1,29 @@
+import {
+  listMcps
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/commands/list.ts
+async function listCommand(options) {
+  const mcps = listMcps();
+  logger.info(`${mcps.length} MCPs dispon\xEDveis no cat\xE1logo:
+`);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const mcp of mcps) {
+    const list = byCategory.get(mcp.category) || [];
+    list.push(mcp);
+    byCategory.set(mcp.category, list);
+  }
+  for (const [category, categoryMcps] of byCategory) {
+    console.log(`  ${category.toUpperCase()}`);
+    for (const mcp of categoryMcps) {
+      console.log(`    ${mcp.name.padEnd(16)} ${mcp.authType.padEnd(8)} ${mcp.displayName}`);
+    }
+    console.log("");
+  }
+}
+export {
+  listCommand
+};

package/dist/profiles-HU3NVRTV.js

@@ -0,0 +1,30 @@
+import {
+  listProfiles
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/commands/profiles.ts
+async function profilesCommand(options) {
+  const profiles = listProfiles();
+  logger.info("Profiles dispon\xEDveis:\n");
+  for (const profile of profiles) {
+    console.log(`  ${profile.name.padEnd(10)} ${String(profile.mcpCount).padStart(2)} MCPs \u2014 ${profile.description}`);
+  }
+  if (options.verbose) {
+    console.log("");
+    for (const profile of profiles) {
+      const { loadProfile } = await import("./config-loader-O23HRZIK.js");
+      const full = loadProfile(profile.name);
+      logger.info(`${profile.displayName} (${profile.name}):`);
+      for (const mcp of full.mcps) {
+        console.log(`    - ${mcp}`);
+      }
+      console.log("");
+    }
+  }
+}
+export {
+  profilesCommand
+};

package/dist/remove-T6C2DD7O.js

@@ -0,0 +1,39 @@
+import {
+  loadMcp
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/commands/remove.ts
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCb);
+async function removeCommand(mcp, options) {
+  let mcpDef;
+  try {
+    mcpDef = loadMcp(mcp);
+  } catch {
+    logger.error(`MCP "${mcp}" n\xE3o encontrado no cat\xE1logo`);
+    process.exit(1);
+  }
+  logger.info(`Removendo MCP "${mcpDef.displayName}"...`);
+  const scopeFlag = options.scope ? `-s ${options.scope}` : "";
+  const command = `claude mcp remove ${mcp} ${scopeFlag}`.trim();
+  try {
+    const { stdout } = await exec(command);
+    logger.success(`MCP ${mcpDef.displayName} removido com sucesso`);
+    if (stdout.trim()) console.log(`  ${stdout.trim()}`);
+  } catch (error) {
+    const msg = error.stderr || error.message;
+    if (msg.includes("not found") || msg.includes("n\xE3o encontrado")) {
+      logger.warn(`MCP ${mcpDef.displayName} n\xE3o est\xE1 configurado`);
+    } else {
+      logger.error(`Falha ao remover ${mcpDef.displayName}: ${msg}`);
+      process.exit(1);
+    }
+  }
+}
+export {
+  removeCommand
+};

package/dist/update-GOCA4IZG.js

@@ -0,0 +1,55 @@
+import {
+  executeCommand,
+  generateCommand,
+  resolveScope
+} from "./chunk-H3PELLAE.js";
+import {
+  listMcps,
+  loadMcp
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/commands/update.ts
+async function updateCommand(mcp, options) {
+  if (!mcp && !options.all) {
+    logger.info("Especifique um MCP para atualizar ou use --all para atualizar todos");
+    logger.info("Exemplo: mcp-setup update github");
+    logger.info("         mcp-setup update --all");
+    return;
+  }
+  const mcpsToUpdate = mcp ? [mcp] : listMcps().map((m) => m.name);
+  logger.info(`Atualizando ${mcpsToUpdate.length} MCP(s)...`);
+  let updated = 0;
+  let failed = 0;
+  for (const mcpName of mcpsToUpdate) {
+    try {
+      const mcpDef = loadMcp(mcpName);
+      const scope = resolveScope(mcpName);
+      const cmd = generateCommand(mcpDef, scope);
+      if (options.dryRun) {
+        logger.info(`[dry-run] ${cmd.command}`);
+        continue;
+      }
+      const result = await executeCommand(cmd, false);
+      if (result.success) {
+        logger.success(`${mcpDef.displayName} atualizado`);
+        updated++;
+      } else {
+        logger.warn(`${mcpDef.displayName}: ${result.message}`);
+        failed++;
+      }
+    } catch (error) {
+      logger.warn(`${mcpName}: ${error.message}`);
+      failed++;
+    }
+  }
+  if (!options.dryRun) {
+    console.log("");
+    logger.info(`${updated} atualizado(s), ${failed} falha(s)`);
+  }
+}
+export {
+  updateCommand
+};