php-universal-mcp-server/src/ftp-uploader.js

Servidor MCP universal para desenvolvimento PHP e criação de sites em qualquer provedor de hospedagem

/**
 * FTP Uploader para PHP Universal MCP Server
 * Permite o upload de sites para servidores via FTP/SFTP
 * 
 * @version 1.0.0
 * @license MIT
 */
const ftp = require('basic-ftp');
const path = require('path');
const fs = require('fs');
const EventEmitter = require('events');

class FTPUploader extends EventEmitter {
  /**
   * Inicializa o uploader FTP
   * @param {Object} config - Configurações
   */
  constructor(config = {}) {
    super();
    
    this.config = {
      sitesDir: config.sitesDir || path.join(process.cwd(), 'sites'),
      tempDir: config.tempDir || path.join(process.cwd(), 'temp'),
      retryCount: config.retryCount || 3,
      verbose: config.verbose || false,
      ...config
    };
    
    // Cria diretório temporário se não existir
    if (!fs.existsSync(this.config.tempDir)) {
      fs.mkdirSync(this.config.tempDir, { recursive: true });
    }
  }

  /**
   * Faz upload de um site para um servidor FTP
   * @param {Object} options - Opções de upload
   * @returns {Promise<Object>} Resultado do upload
   */
  async uploadSite(options) {
    const { domain, ftpHost, ftpUser, ftpPassword, ftpPort = 21, ftpPath = '/', useTLS = true } = options;
    
    if (!domain) {
      return {
        success: false,
        error: 'Domínio do site não especificado',
        timestamp: new Date().toISOString()
      };
    }
    
    if (!ftpHost || !ftpUser || !ftpPassword) {
      return {
        success: false,
        error: 'Credenciais FTP incompletas (host, usuário ou senha)',
        timestamp: new Date().toISOString()
      };
    }
    
    const siteDir = path.join(this.config.sitesDir, domain);
    
    if (!fs.existsSync(siteDir)) {
      return {
        success: false,
        error: `Site '${domain}' não encontrado em ${siteDir}`,
        timestamp: new Date().toISOString()
      };
    }
    
    // Cria cliente FTP
    const client = new ftp.Client();
    client.ftp.verbose = false; // Desativa logs detalhados
    
    try {
      // Conecta ao servidor FTP
      await client.access({
        host: ftpHost,
        user: ftpUser,
        password: ftpPassword,
        port: ftpPort,
        secure: useTLS
      });
      
      // Navega para o diretório de destino
      await client.ensureDir(ftpPath);
      
      // Faz upload recursivo do diretório do site
      await client.uploadFromDir(siteDir);
      
      // Fecha a conexão
      client.close();
      
      return {
        success: true,
        domain,
        ftpHost,
        ftpPath,
        message: `Site '${domain}' foi enviado com sucesso para ${ftpHost}${ftpPath}`,
        timestamp: new Date().toISOString()
      };
    } catch (error) {
      // Garante que a conexão seja fechada
      client.close();
      
      return {
        success: false,
        error: `Erro ao fazer upload: ${error.message}`,
        timestamp: new Date().toISOString()
      };
    }
  }
}

module.exports = FTPUploader;