mcp-styledbook/verificar-mcp.js

Model Context Protocol para criação de ebooks estilizados com pesquisa profunda e formatação visual impactante

#!/usr/bin/env node

/**
 * Script para verificar se o MCP StyledBook está funcionando corretamente
 * Este script tenta usar o npx para executar o MCP e verificar se está acessível
 */

const { spawn } = require('child_process');
const http = require('http');
const fs = require('fs');
const path = require('path');
const os = require('os');

// Banner
console.log('\n');
console.log('███████╗████████╗██╗   ██╗██╗     ███████╗██████╗ ██████╗  ██████╗  ██████╗ ██╗  ██╗');
console.log('██╔════╝╚══██╔══╝╚██╗ ██╔╝██║     ██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔═══██╗██║ ██╔╝');
console.log('███████╗   ██║    ╚████╔╝ ██║     █████╗  ██║  ██║██████╔╝██║   ██║██║   ██║█████╔╝ ');
console.log('╚════██║   ██║     ╚██╔╝  ██║     ██╔══╝  ██║  ██║██╔══██╗██║   ██║██║   ██║██╔═██╗ ');
console.log('███████║   ██║      ██║   ███████╗███████╗██████╔╝██████╔╝╚██████╔╝╚██████╔╝██║  ██╗');
console.log('╚══════╝   ╚═╝      ╚═╝   ╚══════╝╚══════╝╚═════╝ ╚═════╝  ╚═════╝  ╚═════╝ ╚═╝  ╚═╝');
console.log('\n🔍 VERIFICADOR MCP STYLEDBOOK\n');

// Cores para o console
const colors = {
  reset: '\x1b[0m',
  green: '\x1b[32m',
  red: '\x1b[31m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m'
};

// Função para verificar se o Node.js está instalado
async function verificarNodeJS() {
  console.log(`${colors.blue}[1/5]${colors.reset} Verificando instalação do Node.js...`);
  
  try {
    const { execSync } = require('child_process');
    const nodeVersion = execSync('node --version').toString().trim();
    const npmVersion = execSync('npm --version').toString().trim();
    console.log(`${colors.green}✓ Node.js ${nodeVersion} e npm ${npmVersion} estão instalados.${colors.reset}`);
    return true;
  } catch (error) {
    console.log(`${colors.red}✗ Node.js não está instalado ou não está no PATH.${colors.reset}`);
    console.log(`${colors.yellow}→ Instale o Node.js em: https://nodejs.org/${colors.reset}`);
    return false;
  }
}

// Função para verificar se o npx está disponível
async function verificarNpx() {
  console.log(`${colors.blue}[2/5]${colors.reset} Verificando disponibilidade do npx...`);
  
  try {
    const { execSync } = require('child_process');
    const npxVersion = execSync('npx --version').toString().trim();
    console.log(`${colors.green}✓ npx ${npxVersion} está disponível.${colors.reset}`);
    return true;
  } catch (error) {
    console.log(`${colors.red}✗ npx não está instalado ou não está no PATH.${colors.reset}`);
    console.log(`${colors.yellow}→ npx geralmente vem com o npm. Tente atualizar o npm: npm install -g npm${colors.reset}`);
    return false;
  }
}

// Função para verificar se o pacote está publicado no npm
async function verificarDisponibilidadeNpm() {
  console.log(`${colors.blue}[3/5]${colors.reset} Verificando disponibilidade do pacote no npm...`);
  
  return new Promise((resolve) => {
    const req = http.get('http://registry.npmjs.org/mcp-styledbook', (res) => {
      if (res.statusCode === 200) {
        let data = '';
        res.on('data', (chunk) => {
          data += chunk;
        });
        res.on('end', () => {
          try {
            const npmInfo = JSON.parse(data);
            const latestVersion = npmInfo['dist-tags'].latest;
            console.log(`${colors.green}✓ mcp-styledbook está disponível no npm (versão ${latestVersion}).${colors.reset}`);
            resolve(true);
          } catch (e) {
            console.log(`${colors.red}✗ Erro ao processar informações do npm.${colors.reset}`);
            resolve(false);
          }
        });
      } else if (res.statusCode === 404) {
        console.log(`${colors.red}✗ O pacote mcp-styledbook não foi encontrado no npm.${colors.reset}`);
        console.log(`${colors.yellow}→ Você precisa publicar o pacote: npm publish${colors.reset}`);
        resolve(false);
      } else {
        console.log(`${colors.red}✗ Erro ao verificar o npm: status ${res.statusCode}.${colors.reset}`);
        resolve(false);
      }
    });
    
    req.on('error', (e) => {
      console.log(`${colors.red}✗ Erro de conexão com o npm registry: ${e.message}.${colors.reset}`);
      console.log(`${colors.yellow}→ Verifique sua conexão com a internet.${colors.reset}`);
      resolve(false);
    });
    
    req.end();
  });
}

// Função para verificar o arquivo de configuração do MCP
async function verificarArquivoConfiguracao() {
  console.log(`${colors.blue}[4/5]${colors.reset} Verificando arquivo de configuração do MCP...`);
  
  // Verifica configuração global
  const homedir = os.homedir();
  const configDirGlobal = path.join(homedir, '.cursor');
  const configFileGlobal = path.join(configDirGlobal, 'mcp.json');
  
  // Verifica configuração local
  const configDirLocal = path.join(process.cwd(), '.cursor');
  const configFileLocal = path.join(configDirLocal, 'mcp.json');
  
  let configEncontrada = false;
  
  if (fs.existsSync(configFileGlobal)) {
    console.log(`${colors.green}✓ Arquivo de configuração global encontrado em:${colors.reset} ${configFileGlobal}`);
    try {
      const config = JSON.parse(fs.readFileSync(configFileGlobal, 'utf8'));
      if (config.mcpServers && config.mcpServers.styledbook) {
        console.log(`${colors.green}✓ Configuração para styledbook encontrada no arquivo global.${colors.reset}`);
        configEncontrada = true;
      }
    } catch (error) {
      console.log(`${colors.red}✗ Erro ao analisar o arquivo de configuração global: ${error.message}.${colors.reset}`);
    }
  }
  
  if (fs.existsSync(configFileLocal)) {
    console.log(`${colors.green}✓ Arquivo de configuração local encontrado em:${colors.reset} ${configFileLocal}`);
    try {
      const config = JSON.parse(fs.readFileSync(configFileLocal, 'utf8'));
      if (config.mcpServers && config.mcpServers.styledbook) {
        console.log(`${colors.green}✓ Configuração para styledbook encontrada no arquivo local.${colors.reset}`);
        configEncontrada = true;
      }
    } catch (error) {
      console.log(`${colors.red}✗ Erro ao analisar o arquivo de configuração local: ${error.message}.${colors.reset}`);
    }
  }
  
  if (!configEncontrada) {
    console.log(`${colors.yellow}⚠ Nenhuma configuração para MCP StyledBook encontrada.${colors.reset}`);
    console.log(`${colors.yellow}→ Execute um dos scripts de instalação:${colors.reset}`);
    console.log(`   - Windows: mcp-install-windows.bat`);
    console.log(`   - macOS/Linux: ./mcp-install-unix.sh`);
    return false;
  }
  
  return true;
}

// Função para testar o MCP com HTTP
async function testarMcpHttp() {
  console.log(`${colors.blue}[5/5]${colors.reset} Testando MCP StyledBook via HTTP...`);
  
  return new Promise((resolve) => {
    // Porta para o teste
    const testPort = 3456;
    
    // Inicia o servidor MCP
    const serverProcess = spawn('npx', ['-y', 'mcp-styledbook', '--port=' + testPort, '--transport=http', '--json'], {
      stdio: ['ignore', 'pipe', 'pipe'],
      shell: true
    });
    
    let serverOutput = '';
    let serverError = '';
    let serverStarted = false;
    
    // Timeout para aguardar o servidor iniciar
    const timeout = setTimeout(() => {
      if (!serverStarted) {
        console.log(`${colors.red}✗ Timeout ao aguardar o servidor iniciar.${colors.reset}`);
        if (serverError) {
          console.log(`${colors.red}Erro: ${serverError}${colors.reset}`);
        }
        if (serverProcess) serverProcess.kill();
        resolve(false);
      }
    }, 15000);
    
    serverProcess.stdout.on('data', (data) => {
      serverOutput += data.toString();
      if (!serverStarted && serverOutput.includes('"status":"starting"')) {
        serverStarted = true;
        clearTimeout(timeout);
        
        // Aguarda um pouco para o servidor estar completamente pronto
        setTimeout(() => {
          // Faz uma requisição de teste para o servidor
          const req = http.request({
            hostname: 'localhost',
            port: testPort,
            path: '/mcp',
            method: 'POST',
            headers: {
              'Content-Type': 'application/json'
            }
          }, (res) => {
            let data = '';
            
            res.on('data', (chunk) => {
              data += chunk;
            });
            
            res.on('end', () => {
              serverProcess.kill();
              
              if (res.statusCode === 200) {
                console.log(`${colors.green}✓ MCP StyledBook respondeu com sucesso!${colors.reset}`);
                resolve(true);
              } else {
                console.log(`${colors.red}✗ MCP StyledBook respondeu com status ${res.statusCode}.${colors.reset}`);
                console.log(`${colors.yellow}→ Resposta: ${data}${colors.reset}`);
                resolve(false);
              }
            });
          });
          
          req.on('error', (error) => {
            serverProcess.kill();
            console.log(`${colors.red}✗ Erro ao conectar com o MCP: ${error.message}.${colors.reset}`);
            resolve(false);
          });
          
          // Envia uma requisição para o método info
          req.write(JSON.stringify({
            jsonrpc: "2.0",
            id: "test",
            method: "info"
          }));
          
          req.end();
        }, 2000);
      }
    });
    
    serverProcess.stderr.on('data', (data) => {
      serverError += data.toString();
    });
    
    serverProcess.on('error', (error) => {
      clearTimeout(timeout);
      console.log(`${colors.red}✗ Erro ao iniciar o MCP: ${error.message}.${colors.reset}`);
      resolve(false);
    });
  });
}

// Função principal
async function verificarTudo() {
  console.log(`${colors.magenta}🔎 Iniciando verificação do MCP StyledBook...${colors.reset}\n`);
  
  const nodeOK = await verificarNodeJS();
  if (!nodeOK) return false;
  
  const npxOK = await verificarNpx();
  if (!npxOK) return false;
  
  const npmOK = await verificarDisponibilidadeNpm();
  if (!npmOK) return false;
  
  const configOK = await verificarArquivoConfiguracao();
  
  const testOK = await testarMcpHttp();
  
  console.log(`\n${colors.magenta}📊 RESULTADO DA VERIFICAÇÃO:${colors.reset}`);
  console.log(`${colors.blue}------------------------${colors.reset}`);
  console.log(`Node.js:       ${nodeOK ? colors.green + '✓ OK' : colors.red + '✗ FALHA'}`);
  console.log(`npx:           ${npxOK ? colors.green + '✓ OK' : colors.red + '✗ FALHA'}`);
  console.log(`npm:           ${npmOK ? colors.green + '✓ OK' : colors.red + '✗ FALHA'}`);
  console.log(`Configuração:  ${configOK ? colors.green + '✓ OK' : colors.yellow + '⚠ AVISO'}`);
  console.log(`Teste HTTP:    ${testOK ? colors.green + '✓ OK' : colors.red + '✗ FALHA'}`);
  console.log(`${colors.blue}------------------------${colors.reset}`);
  
  if (nodeOK && npxOK && npmOK && testOK) {
    console.log(`\n${colors.green}✅ MCP StyledBook está pronto para uso!${colors.reset}`);
    if (!configOK) {
      console.log(`${colors.yellow}⚠ Mas a configuração do arquivo mcp.json não foi encontrada.${colors.reset}`);
      console.log(`${colors.yellow}  Execute um dos scripts de instalação para configurar automáticamente.${colors.reset}`);
    }
    return true;
  } else {
    console.log(`\n${colors.red}❌ Foram encontrados problemas com o MCP StyledBook.${colors.reset}`);
    console.log(`${colors.yellow}  Consulte o guia de resolução de problemas em SOLUCAO_PROBLEMAS.md${colors.reset}`);
    return false;
  }
}

// Executa a verificação
verificarTudo().then((resultado) => {
  process.exit(resultado ? 0 : 1);
});