@edilsonfjdev/mcp-setup 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Edilson Júnior
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# MCP Setup
+
+> Solução padronizada para instalação e configuração de MCP Servers no Claude Code, adaptável a qualquer tipo de projeto.
+
+## Visão Geral
+
+O MCP Setup é uma solução que padroniza e automatiza a configuração de servidores MCP (Model Context Protocol) para o Claude Code. Permite que desenvolvedores, arquitetos e equipes configurem rapidamente as integrações necessárias para seus projetos, sem precisar repetir trabalho manual ou conhecer detalhes de autenticação de cada serviço.
+
+Destinado a profissionais e equipes que trabalham com múltiplos projetos de software — desde sites estáticos até plataformas SaaS com pagamentos, automação e IA.
+
+## Problema
+
+Configurar integrações MCP manualmente para cada novo projeto gera:
+
+- **Retrabalho** — mesmas configurações repetidas em cada projeto
+- **Inconsistência** — configurações divergem entre projetos e membros da equipe
+- **Risco de segurança** — credenciais mal gerenciadas ou expostas em repositórios
+- **Barreira de entrada** — cada integração exige conhecimento específico de autenticação e configuração
+
+## Funcionalidades
+
+- Perfis de configuração pré-definidos por tipo de projeto (5 templates)
+- Instalação automatizada e interativa de servidores MCP
+- Gestão de escopos: global (user), projeto (project) e local
+- Separação segura de credenciais via variáveis de ambiente
+- Documentação integrada de credenciais, segurança e troubleshooting
+- Suporte a 14 integrações MCP padronizadas
+
+## Templates Disponíveis
+
+| Template | MCPs | Cenário de Uso |
+|----------|------|----------------|
+| `minimal` | 3 | Sites estáticos, portfólios, landing pages |
+| `base` | 9 | Projetos padrão com PM, design e deploy |
+| `saas` | 12 | SaaS, CRM, plataformas com pagamentos e banco de dados |
+| `agents` | 14+ | Projetos com agentes IA, workflows N8N, automação |
+| `full` | 14 | Setup global completo (escopo user) |
+
+## MCPs Suportados
+
+| Categoria | MCP | Autenticação |
+|-----------|-----|-------------|
+| **Desenvolvimento** | GitHub | Bearer Token |
+| **Documentação** | Context7 | Nenhuma |
+| **Design** | Figma | OAuth |
+| | Stitch | API Key |
+| **Gestão e Comunicação** | Linear | OAuth |
+| | Slack | OAuth |
+| | ClickUp | OAuth |
+| **Infraestrutura** | Hetzner | API Token |
+| | Coolify | API Token |
+| **Banco de Dados** | PostgreSQL | DSN |
+| **Workflow** | N8N Docs | Nenhuma |
+| | N8N Instance | Bearer Token |
+| **Segurança e Monitoramento** | Semgrep | Nenhuma |
+| | Sentry | OAuth |
+| **Testes** | Playwright | Nenhuma |
+
+## Estrutura do Projeto
+
+```
+mcp-setup/
+├── CLAUDE.md
+├── CHANGELOG.md
+├── README.md
+├── LICENSE
+├── .gitignore
+├── .claude/
+│   ├── rules/
+│   └── documents/
+│       ├── tbs/           # Technical Briefs
+│       ├── adrs/          # Architecture Decision Records
+│       ├── specs/         # Especificações
+│       └── irs/           # Implementation Records
+├── repo/
+│   └── mcp-project-ecope/ # Protótipo e escopo original
+├── templates/              # Templates MCP por tipo de projeto
+├── scripts/                # Scripts de instalação e utilitários
+├── docs/                   # Documentação do projeto
+│   ├── credentials.md
+│   ├── security.md
+│   ├── scopes.md
+│   └── troubleshooting.md
+└── tests/                  # Testes automatizados
+```
+
+## Quick Start
+
+```bash
+# 1. Clone o repositório
+git clone <repo-url> && cd mcp-setup
+
+# 2. Copie o arquivo de variáveis de ambiente
+cp .env.example .env
+
+# 3. Preencha as credenciais no .env
+# Consulte docs/credentials.md para instruções detalhadas
+
+# 4. Execute a instalação com o template desejado
+./scripts/install.sh --template base
+```
+
+> Instruções detalhadas de instalação serão disponibilizadas após a fase de implementação.
+
+## Documentação
+
+| Documento | Descrição |
+|-----------|-----------|
+| [Credenciais](docs/credentials.md) | Como obter e configurar credenciais para cada MCP |
+| [Segurança](docs/security.md) | Boas práticas de segurança para configuração MCP |
+| [Escopos](docs/scopes.md) | Gestão de escopos: user, project e local |
+| [Troubleshooting](docs/troubleshooting.md) | Resolução de problemas comuns |
+
+## Roadmap
+
+- [ ] CLI próprio para instalação e gestão de MCPs
+- [ ] Suporte nativo a Windows (PowerShell/CMD)
+- [ ] Validação automática de credenciais durante instalação
+- [ ] Composição dinâmica de templates (merge/overlay)
+- [ ] Mecanismo de atualização de MCPs já instalados
+- [ ] Testes automatizados para scripts e templates
+
+## Licença
+
+MIT
+
+## Autor
+
+**Edilson Jr** — Tech Advisor & Arquiteto e Engenheiro de Software

package/bin/mcp-setup.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import('../dist/index.js')

package/dist/add-2HOZTV5H.js

@@ -0,0 +1,66 @@
+import {
+  loadEnv,
+  validateCredential
+} from "./chunk-JNVJQZTK.js";
+import {
+  executeCommand,
+  generateCommand,
+  resolveScope
+} from "./chunk-H3PELLAE.js";
+import {
+  listMcps,
+  loadMcp
+} from "./chunk-UZ72QCYF.js";
+import {
+  logger
+} from "./chunk-Q36CDQK6.js";
+
+// src/commands/add.ts
+async function addCommand(mcp, options) {
+  const { scope, dryRun } = options;
+  let mcpDef;
+  try {
+    mcpDef = loadMcp(mcp);
+  } catch {
+    const available = listMcps().map((m) => m.name).join(", ");
+    logger.error(`MCP "${mcp}" n\xE3o encontrado. Dispon\xEDveis: ${available}`);
+    process.exit(1);
+  }
+  logger.info(`Adicionando MCP "${mcpDef.displayName}"...`);
+  if (mcpDef.auth.envVar) {
+    const envResult = loadEnv();
+    if (envResult.success) {
+      const value = envResult.vars[mcpDef.auth.envVar];
+      if (!value) {
+        logger.warn(`Vari\xE1vel ${mcpDef.auth.envVar} n\xE3o encontrada no .env`);
+      } else {
+        const validation = validateCredential(mcpDef.auth.envVar, value);
+        if (!validation.valid) {
+          logger.warn(`${mcpDef.auth.envVar}: ${validation.error}`);
+        }
+      }
+    }
+  }
+  const resolvedScope = resolveScope(mcp, scope);
+  const cmd = generateCommand(mcpDef, resolvedScope);
+  if (dryRun) {
+    logger.info(`[dry-run] ${cmd.command}`);
+    return;
+  }
+  const spinner = logger.spinner(`Instalando ${mcpDef.displayName}...`);
+  const result = await executeCommand(cmd, false);
+  spinner.stop();
+  if (result.success) {
+    if (result.skipped) {
+      logger.warn(`MCP ${mcpDef.displayName} j\xE1 est\xE1 configurado`);
+    } else {
+      logger.success(`MCP ${mcpDef.displayName} adicionado com sucesso (escopo: ${resolvedScope})`);
+    }
+  } else {
+    logger.error(`Falha ao adicionar ${mcpDef.displayName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+export {
+  addCommand
+};

package/dist/chunk-H3PELLAE.js

@@ -0,0 +1,162 @@
+import {
+  loadScopeMap
+} from "./chunk-UZ72QCYF.js";
+
+// src/core/scope-manager.ts
+function resolveScope(mcpName, overrideScope) {
+  if (overrideScope) {
+    const scopeMap2 = loadScopeMap();
+    if (scopeMap2.project.includes(mcpName) && overrideScope === "user") {
+      return "project";
+    }
+    return overrideScope;
+  }
+  const scopeMap = loadScopeMap();
+  if (scopeMap.user.includes(mcpName)) return "user";
+  if (scopeMap.project.includes(mcpName)) return "project";
+  return "user";
+}
+function resolveScopesForProfile(mcpNames, overrideScope) {
+  const scopes = /* @__PURE__ */ new Map();
+  for (const name of mcpNames) {
+    scopes.set(name, resolveScope(name, overrideScope));
+  }
+  return scopes;
+}
+
+// src/core/mcp-installer.ts
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCb);
+async function getInstalledMcps() {
+  try {
+    const { stdout } = await exec("claude mcp list");
+    return stdout.split("\n").map((line) => line.trim().split(/\s+/)[0]).filter((name) => name && name.length > 0 && !name.startsWith("-") && !name.startsWith("="));
+  } catch {
+    return [];
+  }
+}
+function filterAlreadyInstalled(mcps, installed) {
+  const installedSet = new Set(installed.map((n) => n.toLowerCase()));
+  const pending = [];
+  const existing = [];
+  for (const mcp of mcps) {
+    if (installedSet.has(mcp.name.toLowerCase())) {
+      existing.push(mcp);
+    } else {
+      pending.push(mcp);
+    }
+  }
+  return { pending, existing };
+}
+function applyHeadlessMode(mcps) {
+  const resolved = [];
+  const skipped = [];
+  for (const mcp of mcps) {
+    if (mcp.auth.type === "oauth") {
+      const raw = mcp;
+      if (raw.headlessConfig && raw.auth?.headless) {
+        resolved.push({
+          ...mcp,
+          config: raw.headlessConfig,
+          auth: {
+            type: raw.auth.headless.type,
+            envVar: raw.auth.headless.envVar,
+            required: raw.auth.headless.required ?? true
+          }
+        });
+      } else {
+        skipped.push(mcp);
+      }
+    } else {
+      resolved.push(mcp);
+    }
+  }
+  return { resolved, skipped };
+}
+function generateCommand(mcp, scope) {
+  const parts = ["claude", "mcp", "add", mcp.name, "-s", scope];
+  if (mcp.config.type === "http") {
+    parts.push("--url", mcp.config.url);
+    if (mcp.config.headers) {
+      for (const [key, value] of Object.entries(mcp.config.headers)) {
+        parts.push("-H", `"${key}: ${value}"`);
+      }
+    }
+  } else if (mcp.config.type === "stdio") {
+    parts.push("--", mcp.config.command);
+    if (mcp.config.args) {
+      parts.push(...mcp.config.args);
+    }
+    if (mcp.config.env) {
+      for (const [key, value] of Object.entries(mcp.config.env)) {
+        parts.push("-e", `${key}=${value}`);
+      }
+    }
+  }
+  return {
+    mcpName: mcp.name,
+    command: parts.join(" "),
+    scope
+  };
+}
+function generateCommands(mcps, scopes) {
+  return mcps.map((mcp) => {
+    const scope = scopes.get(mcp.name) || "user";
+    return generateCommand(mcp, scope);
+  });
+}
+async function executeCommand(cmd, dryRun) {
+  if (dryRun) {
+    return {
+      mcpName: cmd.mcpName,
+      success: true,
+      message: `[dry-run] ${cmd.command}`,
+      skipped: false
+    };
+  }
+  try {
+    const { stdout } = await exec(cmd.command);
+    return {
+      mcpName: cmd.mcpName,
+      success: true,
+      message: stdout.trim() || `MCP ${cmd.mcpName} instalado com sucesso`,
+      skipped: false
+    };
+  } catch (error) {
+    if (error.stderr?.includes("already exists") || error.stderr?.includes("j\xE1 existe")) {
+      return {
+        mcpName: cmd.mcpName,
+        success: true,
+        message: `MCP ${cmd.mcpName} j\xE1 est\xE1 configurado (ignorado)`,
+        skipped: true
+      };
+    }
+    return {
+      mcpName: cmd.mcpName,
+      success: false,
+      message: error.stderr || error.message,
+      skipped: false
+    };
+  }
+}
+async function executeCommands(commands, dryRun) {
+  const results = [];
+  for (const cmd of commands) {
+    const result = await executeCommand(cmd, dryRun);
+    results.push(result);
+  }
+  return results;
+}
+
+export {
+  resolveScope,
+  resolveScopesForProfile,
+  getInstalledMcps,
+  filterAlreadyInstalled,
+  applyHeadlessMode,
+  generateCommand,
+  generateCommands,
+  executeCommand,
+  executeCommands
+};

package/dist/chunk-JNVJQZTK.js

@@ -0,0 +1,169 @@
+// src/validation/schemas.ts
+import { z } from "zod";
+var githubTokenSchema = z.string({
+  required_error: "GITHUB_TOKEN \xE9 obrigat\xF3rio"
+}).regex(
+  /^(ghp_[a-zA-Z0-9]{36}|github_pat_[a-zA-Z0-9_]{82,})$/,
+  { message: "GITHUB_TOKEN deve come\xE7ar com ghp_ (classic) ou github_pat_ (fine-grained)" }
+);
+var hetznerTokenSchema = z.string({
+  required_error: "HETZNER_API_TOKEN \xE9 obrigat\xF3rio"
+}).regex(
+  /^[a-zA-Z0-9]{64}$/,
+  { message: "HETZNER_API_TOKEN deve ter exatamente 64 caracteres alfanum\xE9ricos" }
+);
+var coolifyUrlSchema = z.string({
+  required_error: "COOLIFY_BASE_URL \xE9 obrigat\xF3rio"
+}).regex(
+  /^https?:\/\/.+/,
+  { message: "COOLIFY_BASE_URL deve ser uma URL v\xE1lida (http:// ou https://)" }
+);
+var coolifyTokenSchema = z.string({
+  required_error: "COOLIFY_ACCESS_TOKEN \xE9 obrigat\xF3rio"
+}).min(40, { message: "COOLIFY_ACCESS_TOKEN deve ter pelo menos 40 caracteres" });
+var databaseUrlSchema = z.string({
+  required_error: "DATABASE_URL \xE9 obrigat\xF3rio"
+}).regex(
+  /^postgres(ql)?:\/\/.+/,
+  { message: "DATABASE_URL deve come\xE7ar com postgres:// ou postgresql://" }
+);
+var stripeKeySchema = z.string({
+  required_error: "STRIPE_SECRET_KEY \xE9 obrigat\xF3rio"
+}).refine(
+  (val) => !val.startsWith("sk_live_"),
+  { message: "PROIBIDO: Chave Stripe de produ\xE7\xE3o (sk_live_) detectada. Use apenas sk_test_ para seguran\xE7a." }
+).pipe(
+  z.string().regex(
+    /^sk_test_[a-zA-Z0-9]{24,}$/,
+    { message: "STRIPE_SECRET_KEY deve come\xE7ar com sk_test_ seguido de no m\xEDnimo 24 caracteres" }
+  )
+);
+var n8nUrlSchema = z.string({
+  required_error: "N8N_URL \xE9 obrigat\xF3rio"
+}).regex(
+  /^https?:\/\/.+/,
+  { message: "N8N_URL deve ser uma URL v\xE1lida (http:// ou https://)" }
+);
+var n8nTokenSchema = z.string({
+  required_error: "N8N_MCP_TOKEN \xE9 obrigat\xF3rio"
+}).min(1, { message: "N8N_MCP_TOKEN n\xE3o pode ser vazio" });
+var stitchKeySchema = z.string({
+  required_error: "STITCH_API_KEY \xE9 obrigat\xF3rio"
+}).min(1, { message: "STITCH_API_KEY n\xE3o pode ser vazio" });
+var credentialSchemas = {
+  GITHUB_TOKEN: githubTokenSchema,
+  HETZNER_API_TOKEN: hetznerTokenSchema,
+  COOLIFY_BASE_URL: coolifyUrlSchema,
+  COOLIFY_ACCESS_TOKEN: coolifyTokenSchema,
+  DATABASE_URL: databaseUrlSchema,
+  STRIPE_SECRET_KEY: stripeKeySchema,
+  N8N_URL: n8nUrlSchema,
+  N8N_MCP_TOKEN: n8nTokenSchema,
+  STITCH_API_KEY: stitchKeySchema
+};
+var requiredVarsByTemplate = {
+  minimal: ["GITHUB_TOKEN"],
+  base: ["GITHUB_TOKEN", "STITCH_API_KEY", "COOLIFY_BASE_URL", "COOLIFY_ACCESS_TOKEN"],
+  saas: ["GITHUB_TOKEN", "STITCH_API_KEY", "COOLIFY_BASE_URL", "COOLIFY_ACCESS_TOKEN", "DATABASE_URL", "STRIPE_SECRET_KEY"],
+  agents: ["GITHUB_TOKEN", "STITCH_API_KEY", "COOLIFY_BASE_URL", "COOLIFY_ACCESS_TOKEN", "DATABASE_URL", "HETZNER_API_TOKEN", "N8N_URL", "N8N_MCP_TOKEN"],
+  full: ["GITHUB_TOKEN", "STITCH_API_KEY", "COOLIFY_BASE_URL", "COOLIFY_ACCESS_TOKEN", "HETZNER_API_TOKEN"]
+};
+function validateCredential(name, value) {
+  const schema = credentialSchemas[name];
+  if (!schema) {
+    return { valid: true, variable: name };
+  }
+  const result = schema.safeParse(value);
+  return {
+    valid: result.success,
+    variable: name,
+    error: result.success ? void 0 : result.error.errors[0]?.message
+  };
+}
+function validateAllCredentials(templateName, env) {
+  const required = requiredVarsByTemplate[templateName] || [];
+  return required.map((varName) => {
+    const value = env[varName];
+    if (!value) {
+      return {
+        valid: false,
+        variable: varName,
+        error: `${varName} \xE9 obrigat\xF3rio para o template "${templateName}"`
+      };
+    }
+    return validateCredential(varName, value);
+  });
+}
+
+// src/utils/env.ts
+import { config as dotenvConfig } from "dotenv";
+import { existsSync } from "fs";
+import { resolve } from "path";
+function loadEnv(envPath) {
+  const path = envPath || resolve(process.cwd(), ".env");
+  if (!existsSync(path)) {
+    return {
+      success: false,
+      vars: {},
+      path,
+      error: `Arquivo .env n\xE3o encontrado em ${path}. Copie .env.example para .env e preencha as credenciais.`
+    };
+  }
+  const result = dotenvConfig({ path });
+  if (result.error) {
+    return {
+      success: false,
+      vars: {},
+      path,
+      error: `Erro ao carregar .env: ${result.error.message}`
+    };
+  }
+  return {
+    success: true,
+    vars: result.parsed || {},
+    path
+  };
+}
+var varDescriptions = {
+  GITHUB_TOKEN: { description: "Token de acesso pessoal do GitHub (PAT)", mcpName: "github" },
+  STITCH_API_KEY: { description: "Chave de API do Google Stitch", mcpName: "stitch" },
+  HETZNER_API_TOKEN: { description: "Token de API do Hetzner Cloud", mcpName: "hetzner" },
+  COOLIFY_BASE_URL: { description: "URL base da inst\xE2ncia Coolify", mcpName: "coolify" },
+  COOLIFY_ACCESS_TOKEN: { description: "Token de acesso da API Coolify", mcpName: "coolify" },
+  DATABASE_URL: { description: "String de conex\xE3o PostgreSQL (DSN)", mcpName: "postgres" },
+  STRIPE_SECRET_KEY: { description: "Chave secreta do Stripe (apenas sk_test_)", mcpName: "stripe" },
+  N8N_URL: { description: "URL da inst\xE2ncia N8N", mcpName: "n8n-instance" },
+  N8N_MCP_TOKEN: { description: "Token MCP da inst\xE2ncia N8N", mcpName: "n8n-instance" }
+};
+function getRequiredVars(templateName) {
+  const varNames = requiredVarsByTemplate[templateName] || [];
+  return varNames.map((name) => ({
+    name,
+    description: varDescriptions[name]?.description || name,
+    mcpName: varDescriptions[name]?.mcpName || "desconhecido"
+  }));
+}
+function validatePresence(env, required) {
+  const present = [];
+  const missing = [];
+  for (const req of required) {
+    if (env[req.name] && env[req.name].trim() !== "") {
+      present.push(req.name);
+    } else {
+      missing.push(req);
+    }
+  }
+  return {
+    valid: missing.length === 0,
+    present,
+    missing
+  };
+}
+
+export {
+  validateCredential,
+  validateAllCredentials,
+  loadEnv,
+  getRequiredVars,
+  validatePresence
+};

package/dist/chunk-Q36CDQK6.js

@@ -0,0 +1,28 @@
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var noColor = process.argv.includes("--no-color");
+var verbose = process.argv.includes("--verbose");
+if (noColor) {
+  chalk.level = 0;
+}
+var logger = {
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  error: (msg) => console.error(chalk.red("\u2717"), msg),
+  warn: (msg) => console.log(chalk.yellow("!"), msg),
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  debug: (msg) => {
+    if (verbose) console.log(chalk.gray("\u22EF"), msg);
+  },
+  spinner: (msg) => {
+    if (noColor) {
+      console.log(`... ${msg}`);
+      return ora({ text: msg, isEnabled: false });
+    }
+    return ora(msg).start();
+  }
+};
+
+export {
+  logger
+};

package/dist/chunk-UZ72QCYF.js

@@ -0,0 +1,79 @@
+// src/core/config-loader.ts
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+function templatesDir() {
+  const fromCwd = resolve(process.cwd(), "templates");
+  if (existsSync(fromCwd)) return fromCwd;
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  return resolve(__dirname2, "..", "templates");
+}
+function loadMcp(name) {
+  const filePath = resolve(templatesDir(), "mcps", `${name}.json`);
+  if (!existsSync(filePath)) {
+    throw new Error(`MCP "${name}" n\xE3o encontrado em templates/mcps/${name}.json`);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadProfile(name) {
+  const customPaths = [
+    resolve(process.cwd(), ".mcp-setup", "profiles", `${name}.json`),
+    resolve(process.env.HOME || process.env.USERPROFILE || "", ".mcp-setup", "profiles", `${name}.json`)
+  ];
+  for (const customPath of customPaths) {
+    if (existsSync(customPath)) {
+      const content2 = readFileSync(customPath, "utf-8");
+      return JSON.parse(content2);
+    }
+  }
+  const filePath = resolve(templatesDir(), "profiles", `${name}.json`);
+  if (!existsSync(filePath)) {
+    const available = listProfiles().map((p) => p.name).join(", ");
+    throw new Error(`Profile "${name}" n\xE3o encontrado. Dispon\xEDveis: ${available}`);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadScopeMap() {
+  const filePath = resolve(templatesDir(), "scopes", "scope-map.json");
+  const content = readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function listProfiles() {
+  const profilesDir = resolve(templatesDir(), "profiles");
+  const files = readdirSync(profilesDir).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    const content = readFileSync(resolve(profilesDir, f), "utf-8");
+    const profile = JSON.parse(content);
+    return {
+      name: profile.name,
+      displayName: profile.displayName,
+      description: profile.description,
+      mcpCount: profile.mcps.length
+    };
+  });
+}
+function listMcps() {
+  const mcpsDir = resolve(templatesDir(), "mcps");
+  const files = readdirSync(mcpsDir).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    const content = readFileSync(resolve(mcpsDir, f), "utf-8");
+    const mcp = JSON.parse(content);
+    return {
+      name: mcp.name,
+      displayName: mcp.displayName,
+      category: mcp.category,
+      authType: mcp.auth.type
+    };
+  });
+}
+
+export {
+  loadMcp,
+  loadProfile,
+  loadScopeMap,
+  listProfiles,
+  listMcps
+};

package/dist/config-loader-O23HRZIK.js

@@ -0,0 +1,14 @@
+import {
+  listMcps,
+  listProfiles,
+  loadMcp,
+  loadProfile,
+  loadScopeMap
+} from "./chunk-UZ72QCYF.js";
+export {
+  listMcps,
+  listProfiles,
+  loadMcp,
+  loadProfile,
+  loadScopeMap
+};