mozhost-cli 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mozhost-cli",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Command-line interface for MozHost container platform",
   "main": "index.js",
   "bin": {

package/src/commands/containers.js

@@ -3,12 +3,60 @@ const ora = require('ora');
 const inquirer = require('inquirer');
 const api = require('../utils/api');
 
+// ============================================
+// HELPER FUNCTION - Resolver Nome ou ID
+// ============================================
+async function resolveContainer(identifier) {
+  try {
+    // Tenta buscar diretamente por ID
+    const response = await api.getContainer(identifier);
+    return response.container;
+  } catch (error) {
+    // Se não encontrar (404), busca na lista por nome
+    if (error.response?.status === 404 || error.response?.data?.error?.includes('not found')) {
+      const listResponse = await api.listContainers();
+      
+      // Procura por nome, ID completo ou ID parcial
+      const found = listResponse.containers.find(c => 
+        c.name === identifier || 
+        c.id === identifier ||
+        c.id.startsWith(identifier)
+      );
+      
+      if (!found) {
+        // Procura containers similares para sugerir
+        const similar = listResponse.containers.filter(c => 
+          c.name.toLowerCase().includes(identifier.toLowerCase()) ||
+          c.id.includes(identifier)
+        );
+        
+        if (similar.length > 0) {
+          console.log(chalk.yellow('\n💡 Você quis dizer:'));
+          similar.forEach(c => {
+            console.log(chalk.white(`   • ${c.name} ${chalk.gray(`(${c.id.slice(0, 8)})`)}`));
+          });
+        } else {
+          console.log(chalk.gray('\n💡 Use: mozhost ls para ver todos os containers'));
+        }
+        
+        throw new Error(`Container "${identifier}" não encontrado`);
+      }
+      
+      return found;
+    }
+    throw error;
+  }
+}
+
+// ============================================
+// LIST - Listar todos os containers
+// ============================================
 async function list() {
   try {
     const spinner = ora('Carregando containers...').start();
-    
+
     const response = await api.listContainers();
-    
+
     spinner.stop();
 
     if (response.containers.length === 0) {
@@ -22,7 +70,7 @@ async function list() {
     response.containers.forEach(container => {
       const statusColor = container.status === 'running' ? chalk.green : chalk.gray;
       const statusIcon = container.status === 'running' ? '●' : '○';
-      
+
       console.log(`${statusColor(statusIcon)} ${chalk.white.bold(container.name)} ${chalk.gray(`(${container.id.slice(0, 8)})`)}`);
       console.log(`  ${chalk.gray('Tipo:')} ${container.type}`);
       console.log(`  ${chalk.gray('Status:')} ${statusColor(container.status)}`);
@@ -51,6 +99,9 @@ async function list() {
   }
 }
 
+// ============================================
+// CREATE - Criar novo container
+// ============================================
 async function create(options) {
   try {
     const { name, type } = options;
@@ -79,85 +130,106 @@ async function create(options) {
     console.log(chalk.white(`  Porta: ${response.container.port}`));
 
     console.log(chalk.gray('\nPróximos passos:'));
-    console.log(chalk.white(`  1. mozhost start ${response.container.id}`));
-    console.log(chalk.white(`  2. mozhost deploy ${response.container.id}`));
+    console.log(chalk.white(`  1. mozhost start ${response.container.name}`));
+    console.log(chalk.white(`  2. mozhost deploy ${response.container.name}`));
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao criar container:'));
-    
+
     if (error.response?.data) {
       console.error(chalk.red(`   ${error.response.data.error || error.response.data.message}`));
-      
+
       if (error.response.status === 403) {
         console.log(chalk.yellow('\n💡 Dica: Você atingiu o limite de containers do seu plano'));
       }
-      
+
       if (error.response.status === 402) {
         console.log(chalk.yellow('\n💡 Dica: Você não tem coins suficientes'));
       }
     } else {
       console.error(chalk.red(`   ${error.message}`));
     }
-    
+
     process.exit(1);
   }
 }
 
-async function start(containerId) {
+// ============================================
+// START - Iniciar container
+// ============================================
+async function start(identifier) {
   try {
-    const spinner = ora('Iniciando container...').start();
-    
-    const response = await api.startContainer(containerId);
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
     
-    spinner.succeed(chalk.green(`✅ Container ${response.container.name} iniciado!`));
-    
-    const info = await api.getContainer(containerId);
-    console.log(chalk.cyan(`\n🌐 URL: https://${info.container.domain}`));
+    spinner.text = `Iniciando ${container.name}...`;
+    const response = await api.startContainer(container.id);
+
+    spinner.succeed(chalk.green(`✅ Container ${container.name} iniciado!`));
+
+    console.log(chalk.cyan(`\n🌐 URL: https://${container.domain}`));
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao iniciar container:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function stop(containerId) {
+// ============================================
+// STOP - Parar container
+// ============================================
+async function stop(identifier) {
   try {
-    const spinner = ora('Parando container...').start();
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
     
-    const response = await api.stopContainer(containerId);
-    
-    spinner.succeed(chalk.green(`✅ Container ${response.container.name} parado!`));
+    spinner.text = `Parando ${container.name}...`;
+    await api.stopContainer(container.id);
+
+    spinner.succeed(chalk.green(`✅ Container ${container.name} parado!`));
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao parar container:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function restart(containerId) {
+// ============================================
+// RESTART - Reiniciar container
+// ============================================
+async function restart(identifier) {
   try {
-    const spinner = ora('Reiniciando container...').start();
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
     
-    const response = await api.restartContainer(containerId);
-    
-    spinner.succeed(chalk.green(`✅ Container ${response.container.name} reiniciado!`));
+    spinner.text = `Reiniciando ${container.name}...`;
+    await api.restartContainer(container.id);
+
+    spinner.succeed(chalk.green(`✅ Container ${container.name} reiniciado!`));
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao reiniciar container:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function deleteContainer(containerId) {
+// ============================================
+// DELETE - Deletar container
+// ============================================
+async function deleteContainer(identifier) {
   try {
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
+    spinner.stop();
+
     const confirm = await inquirer.prompt([
       {
         type: 'confirm',
         name: 'confirmed',
-        message: chalk.red('Tem certeza que deseja deletar este container?'),
+        message: chalk.red(`Tem certeza que deseja deletar "${container.name}"?`),
         default: false
       }
     ]);
@@ -167,70 +239,80 @@ async function deleteContainer(containerId) {
       return;
     }
 
-    const spinner = ora('Deletando container...').start();
-    
-    await api.deleteContainer(containerId);
-    
-    spinner.succeed(chalk.green('✅ Container deletado com sucesso!'));
+    const deleteSpinner = ora(`Deletando ${container.name}...`).start();
+    await api.deleteContainer(container.id);
+
+    deleteSpinner.succeed(chalk.green(`✅ Container ${container.name} deletado com sucesso!`));
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao deletar container:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function logs(containerId, options) {
+// ============================================
+// LOGS - Ver logs do container
+// ============================================
+async function logs(identifier, options) {
   try {
-    const spinner = ora('Carregando logs...').start();
-    
-    const response = await api.getContainerLogs(containerId, options.lines);
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
     
+    spinner.text = `Carregando logs de ${container.name}...`;
+    const response = await api.getContainerLogs(container.id, options.lines);
+
     spinner.stop();
 
     if (!response.logs || response.logs.length === 0) {
-      console.log(chalk.yellow('\n⚠️  Nenhum log encontrado'));
+      console.log(chalk.yellow(`\n⚠️  Nenhum log encontrado para ${container.name}`));
       return;
     }
 
-    console.log(chalk.cyan.bold('\n📝 Logs do Container\n'));
+    console.log(chalk.cyan.bold(`\n📝 Logs de ${container.name}\n`));
     response.logs.forEach(line => {
       console.log(chalk.gray(line));
     });
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao buscar logs:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function info(containerId) {
+// ============================================
+// INFO - Informações detalhadas do container
+// ============================================
+async function info(identifier) {
   try {
-    const spinner = ora('Carregando informações...').start();
+    const spinner = ora('Resolvendo container...').start();
+    const container = await resolveContainer(identifier);
     
-    const response = await api.getContainer(containerId);
+    spinner.text = `Carregando informações de ${container.name}...`;
     
+    // Busca detalhes completos (com stats se disponível)
+    const response = await api.getContainer(container.id);
     spinner.stop();
 
-    const container = response.container;
-    
+    const containerData = response.container;
+
     console.log(chalk.cyan.bold('\n📦 Informações do Container\n'));
-    console.log(chalk.white(`  ID: ${container.id}`));
-    console.log(chalk.white(`  Nome: ${container.name}`));
-    console.log(chalk.white(`  Tipo: ${container.type}`));
-    
-    const statusColor = container.status === 'running' ? chalk.green : chalk.gray;
-    console.log(`  Status: ${statusColor(container.status)}`);
-    
-    console.log(chalk.cyan(`  URL: https://${container.domain}`));
-    console.log(chalk.white(`  Porta: ${container.port}`));
-    console.log(chalk.white(`  CPU Limit: ${container.cpu_limit}`));
-    console.log(chalk.white(`  RAM Limit: ${container.memory_limit_mb}MB`));
-    console.log(chalk.white(`  Storage Usado: ${container.storage_used_mb || 0}MB`));
-    console.log(chalk.white(`  Auto Restart: ${container.auto_restart ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`  Criado em: ${new Date(container.created_at).toLocaleString('pt-BR')}`));
-    console.log(chalk.gray(`  Atualizado em: ${new Date(container.updated_at).toLocaleString('pt-BR')}`));
+    console.log(chalk.white(`  ID: ${containerData.id}`));
+    console.log(chalk.white(`  Nome: ${containerData.name}`));
+    console.log(chalk.white(`  Tipo: ${containerData.type}`));
+
+    const statusColor = containerData.status === 'running' ? chalk.green : chalk.gray;
+    console.log(`  Status: ${statusColor(containerData.status)}`);
+
+    console.log(chalk.cyan(`  URL: https://${containerData.domain}`));
+    console.log(chalk.white(`  Porta: ${containerData.port}`));
+    console.log(chalk.white(`  CPU Limit: ${containerData.cpu_limit}`));
+    console.log(chalk.white(`  RAM Limit: ${containerData.memory_limit_mb}MB`));
+    console.log(chalk.white(`  Storage Usado: ${containerData.storage_used_mb || 0}MB`));
+    console.log(chalk.white(`  Auto Restart: ${containerData.auto_restart ? 'Sim' : 'Não'}`));
+    console.log(chalk.gray(`  Criado em: ${new Date(containerData.created_at).toLocaleString('pt-BR')}`));
+    console.log(chalk.gray(`  Atualizado em: ${new Date(containerData.updated_at).toLocaleString('pt-BR')}`));
 
     if (response.stats) {
       console.log(chalk.cyan.bold('\n📊 Estatísticas em Tempo Real\n'));
@@ -240,22 +322,28 @@ async function info(containerId) {
 
   } catch (error) {
     console.error(chalk.red('\n❌ Erro ao buscar informações:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
-async function url(containerId) {
+// ============================================
+// URL - Obter URL do container
+// ============================================
+async function url(identifier) {
   try {
-    const response = await api.getContainer(containerId);
-    console.log(chalk.cyan(`https://${response.container.domain}`));
+    const container = await resolveContainer(identifier);
+    console.log(chalk.cyan(`https://${container.domain}`));
   } catch (error) {
     console.error(chalk.red('❌ Erro ao buscar URL:'));
-    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
     process.exit(1);
   }
 }
 
+// ============================================
+// EXPORTS
+// ============================================
 module.exports = {
   list,
   create,

package/src/commands/domain.js

@@ -0,0 +1,78 @@
+// mozhost-cli/commands/domain.js
+
+const program = require('commander');
+const axios = require('axios');
+const chalk = require('chalk');
+
+program
+  .command('domain add <container> <domain>')
+  .description('Adicionar domínio customizado')
+  .action(async (container, domain) => {
+    try {
+      const res = await axios.post(`${API_URL}/domains`, {
+        containerId: container,
+        domain
+      });
+      
+      console.log(chalk.green('\n✅ Domínio adicionado com sucesso!\n'));
+      console.log(chalk.yellow('📋 Configure seu DNS:\n'));
+      console.log(`   Tipo: ${chalk.bold('A')}`);
+      console.log(`   Nome: ${chalk.bold('@')} (ou ${chalk.bold(domain)})`);
+      console.log(`   Valor: ${chalk.bold(res.data.instructions.ip)}`);
+      console.log(`   TTL: ${chalk.bold('300')}\n`);
+      console.log(chalk.cyan('⏳ Aguardando propagação DNS...\n'));
+      console.log(`Use ${chalk.bold('mozhost domain status ' + container)} para acompanhar\n`);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ Erro:'), error.response?.data?.error || error.message);
+    }
+  });
+
+program
+  .command('domain status <container>')
+  .description('Ver status dos domínios')
+  .action(async (container) => {
+    try {
+      const res = await axios.get(`${API_URL}/domains/${container}`);
+      const domains = res.data;
+      
+      if (domains.length === 0) {
+        console.log(chalk.yellow('Nenhum domínio customizado configurado'));
+        return;
+      }
+      
+      console.log('\n┌─────────────────────────────────────────────────┐');
+      
+      for (const d of domains) {
+        const statusIcon = {
+          pending: '⏳',
+          dns_pending: '🔍',
+          ssl_generating: '🔒',
+          active: '✅',
+          failed: '❌'
+        }[d.status];
+        
+        const statusText = {
+          pending: 'Aguardando configuração',
+          dns_pending: 'DNS detectado, gerando SSL...',
+          ssl_generating: 'Gerando certificado SSL...',
+          active: 'Ativo',
+          failed: 'Falhou - verifique DNS'
+        }[d.status];
+        
+        console.log(`│ ${statusIcon} ${chalk.bold(d.domain)}`);
+        console.log(`│    Status: ${statusText}`);
+        if (d.ssl_expires_at && d.status === 'active') {
+          console.log(`│    SSL válido até: ${new Date(d.ssl_expires_at).toLocaleDateString()}`);
+        }
+        console.log('│');
+      }
+      
+      console.log('└─────────────────────────────────────────────────┘\n');
+      
+    } catch (error) {
+      console.error(chalk.red('❌ Erro:'), error.message);
+    }
+  });
+
+program.parse(process.argv);