mozhost-cli 2.0.0 → 2.1.0

package/bin/mozhost.js

@@ -5,6 +5,7 @@ const chalk = require('chalk');
 const authCommands = require('../src/commands/auth');
 const containerCommands = require('../src/commands/containers');
 const deployCommands = require('../src/commands/deploy');
+const databaseCommands = require('../src/commands/databases'); // 👈 NOVO
 const packageJson = require('../package.json');
 
 program
@@ -12,7 +13,9 @@ program
   .description('CLI for MozHost - Hospedagem de Bots e APIs')
   .version(packageJson.version);
 
-// Auth commands
+// ============================================
+// AUTH COMMANDS
+// ============================================
 program
   .command('auth')
   .description('Autenticar na MozHost')
@@ -28,7 +31,9 @@ program
   .description('Ver usuário atual')
   .action(authCommands.whoami);
 
-// Container commands
+// ============================================
+// CONTAINER COMMANDS
+// ============================================
 program
   .command('containers')
   .alias('ls')
@@ -79,7 +84,48 @@ program
   .description('Ver URL do container')
   .action(containerCommands.url);
 
-// Deploy commands
+// ============================================
+// DATABASE COMMANDS 👈 NOVO
+// ============================================
+program
+  .command('db:list')
+  .alias('db:ls')
+  .description('Listar databases')
+  .action(databaseCommands.list);
+
+program
+  .command('db:create')
+  .description('Criar novo database')
+  .requiredOption('-n, --name <name>', 'Nome do database')
+  .requiredOption('-t, --type <type>', 'Tipo (mysql, mariadb, postgres, mongodb, redis)')
+  .option('-c, --container <container>', 'Container para vincular (opcional)')
+  .action(databaseCommands.create);
+
+program
+  .command('db:info <database>')
+  .description('Ver informações detalhadas do database')
+  .action(databaseCommands.info);
+
+program
+  .command('db:credentials <database>')
+  .alias('db:creds')
+  .description('Ver credenciais do database')
+  .action(databaseCommands.credentials);
+
+program
+  .command('db:link <database> <container>')
+  .description('Vincular database a um container')
+  .action(databaseCommands.link);
+
+program
+  .command('db:delete <database>')
+  .alias('db:rm')
+  .description('Deletar database')
+  .action(databaseCommands.deleteDatabase);
+
+// ============================================
+// DEPLOY COMMANDS
+// ============================================
 program
   .command('init')
   .description('Inicializar projeto para deploy')
@@ -96,11 +142,22 @@ program
   .description('Vincular diretório atual a um container')
   .action(deployCommands.link);
 
-// Parse arguments
+// ============================================
+// PARSE & HELP
+// ============================================
 program.parse(process.argv);
 
 // Show help if no command
 if (!process.argv.slice(2).length) {
   console.log(chalk.cyan.bold('\n🚀 MozHost CLI\n'));
   program.outputHelp();
+  
+  // Mostrar exemplos úteis
+  console.log(chalk.gray('\nExemplos:'));
+  console.log(chalk.white('  mozhost auth                     # Autenticar'));
+  console.log(chalk.white('  mozhost ls                       # Listar containers'));
+  console.log(chalk.white('  mozhost create -n app -t nodejs  # Criar container'));
+  console.log(chalk.white('  mozhost db:list                  # Listar databases'));
+  console.log(chalk.white('  mozhost db:create -n db -t mysql # Criar database'));
+  console.log();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mozhost-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "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/databases.js

@@ -0,0 +1,389 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const api = require('../utils/api');
+
+// ============================================
+// HELPER FUNCTION - Resolver Nome ou ID
+// ============================================
+async function resolveDatabase(identifier) {
+  try {
+    // Tenta buscar diretamente por ID
+    const response = await api.getDatabase(identifier);
+    return response.database;
+  } 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.listDatabases();
+
+      // Procura por nome, ID completo ou ID parcial
+      const found = listResponse.databases.find(d =>
+        d.name === identifier ||
+        d.id === identifier ||
+        d.id.startsWith(identifier)
+      );
+
+      if (!found) {
+        // Procura databases similares para sugerir
+        const similar = listResponse.databases.filter(d =>
+          d.name.toLowerCase().includes(identifier.toLowerCase()) ||
+          d.id.includes(identifier)
+        );
+
+        if (similar.length > 0) {
+          console.log(chalk.yellow('\n💡 Você quis dizer:'));
+          similar.forEach(d => {
+            console.log(chalk.white(`   • ${d.name} ${chalk.gray(`(${d.id.slice(0, 8)}) - ${d.type}`)}`));
+          });
+        } else {
+          console.log(chalk.gray('\n💡 Use: mozhost db:list para ver todos os databases'));
+        }
+
+        throw new Error(`Database "${identifier}" não encontrado`);
+      }
+
+      return found;
+    }
+    throw error;
+  }
+}
+
+// ============================================
+// LIST - Listar todos os databases
+// ============================================
+async function list() {
+  try {
+    const spinner = ora('Carregando databases...').start();
+
+    const response = await api.listDatabases();
+
+    spinner.stop();
+
+    if (response.databases.length === 0) {
+      console.log(chalk.yellow('\n⚠️  Nenhum database encontrado'));
+      console.log(chalk.gray('   Use: mozhost db:create --name <nome> --type <tipo>'));
+      return;
+    }
+
+    console.log(chalk.cyan.bold(`\n💾 Databases (${response.databases.length})\n`));
+
+    response.databases.forEach(database => {
+      const statusColor = database.status === 'running' ? chalk.green : chalk.gray;
+      const statusIcon = database.status === 'running' ? '●' : '○';
+
+      // Ícones por tipo de database
+      const typeIcons = {
+        mysql: '🐬',
+        mariadb: '🦭',
+        postgres: '🐘',
+        mongodb: '🍃',
+        redis: '🔴'
+      };
+      const typeIcon = typeIcons[database.type] || '💾';
+
+      console.log(`${statusColor(statusIcon)} ${typeIcon} ${chalk.white.bold(database.name)} ${chalk.gray(`(${database.id.slice(0, 8)})`)}`);
+      console.log(`  ${chalk.gray('Tipo:')} ${database.type}`);
+      console.log(`  ${chalk.gray('Status:')} ${statusColor(database.status)}`);
+      console.log(`  ${chalk.gray('Host:')} ${chalk.cyan(database.host)}`);
+      console.log(`  ${chalk.gray('Porta:')} ${database.port}`);
+      console.log(`  ${chalk.gray('Database:')} ${database.database_name}`);
+      
+      if (database.containers && database.containers.length > 0) {
+        console.log(`  ${chalk.gray('Containers:')} ${database.containers.join(', ')}`);
+      }
+      console.log();
+    });
+
+    if (response.total_cost !== undefined) {
+      console.log(chalk.yellow(`💰 Custo total: ${response.total_cost} coins/dia\n`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao listar databases:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+// ============================================
+// CREATE - Criar novo database
+// ============================================
+async function create(options) {
+  try {
+    const { name, type, container } = options;
+
+    if (!name || !type) {
+      console.error(chalk.red('❌ Nome e tipo são obrigatórios'));
+      console.log(chalk.gray('   Use: mozhost db:create --name <nome> --type <tipo>'));
+      process.exit(1);
+    }
+
+    const validTypes = ['mysql', 'mariadb', 'postgres', 'mongodb', 'redis'];
+    if (!validTypes.includes(type)) {
+      console.error(chalk.red('❌ Tipo inválido'));
+      console.log(chalk.gray('   Tipos válidos: mysql, mariadb, postgres, mongodb, redis'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan.bold('\n🔨 Criando database...\n'));
+    console.log(chalk.gray(`  Nome: ${name}`));
+    console.log(chalk.gray(`  Tipo: ${type}`));
+    if (container) {
+      console.log(chalk.gray(`  Container: ${container}`));
+    }
+    console.log();
+
+    const spinner = ora('Criando database...').start();
+
+    const response = await api.createDatabase({ name, type, container });
+
+    spinner.succeed(chalk.green('✅ Database criado com sucesso!'));
+
+    const db = response.database;
+
+    console.log(chalk.gray('\n📋 Informações do Database:'));
+    console.log(chalk.white(`  ID: ${db.id}`));
+    console.log(chalk.white(`  Nome: ${db.name}`));
+    console.log(chalk.white(`  Tipo: ${db.type}`));
+    console.log(chalk.white(`  Status: ${db.status}`));
+    console.log(chalk.cyan(`  Host: ${db.host}`));
+    console.log(chalk.white(`  Porta: ${db.port}`));
+    console.log(chalk.white(`  Database: ${db.database_name}`));
+    console.log(chalk.white(`  Username: ${db.username}`));
+    console.log(chalk.yellow(`  Password: ${db.password}`));
+    console.log(chalk.yellow(`  💰 Custo: ${db.cost} coins/dia`));
+
+    console.log(chalk.gray('\n🔗 Connection String:'));
+    console.log(chalk.cyan(`  ${db.connection_string}`));
+
+    console.log(chalk.gray('\n💡 Dicas:'));
+    console.log(chalk.white(`  • Guarde a senha em local seguro`));
+    console.log(chalk.white(`  • Use: mozhost db:credentials ${db.name} para ver novamente`));
+    if (!container) {
+      console.log(chalk.white(`  • Use: mozhost db:link ${db.name} <container> para vincular`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao criar database:'));
+
+    if (error.response?.data) {
+      console.error(chalk.red(`   ${error.response.data.error || error.response.data.message}`));
+
+      if (error.response.status === 400 && error.response.data.error?.includes('Insufficient coins')) {
+        console.log(chalk.yellow('\n💡 Dica: Você não tem coins suficientes (necessário: 5 coins)'));
+      }
+    } else {
+      console.error(chalk.red(`   ${error.message}`));
+    }
+
+    process.exit(1);
+  }
+}
+
+// ============================================
+// INFO - Informações detalhadas do database
+// ============================================
+async function info(identifier) {
+  try {
+    const spinner = ora('Resolvendo database...').start();
+    const database = await resolveDatabase(identifier);
+
+    spinner.text = `Carregando informações de ${database.name}...`;
+
+    // Busca detalhes completos
+    const response = await api.getDatabase(database.id);
+    spinner.stop();
+
+    const db = response.database;
+
+    // Ícones por tipo
+    const typeIcons = {
+      mysql: '🐬',
+      mariadb: '🦭',
+      postgres: '🐘',
+      mongodb: '🍃',
+      redis: '🔴'
+    };
+    const typeIcon = typeIcons[db.type] || '💾';
+
+    console.log(chalk.cyan.bold(`\n${typeIcon} Informações do Database\n`));
+    console.log(chalk.white(`  ID: ${db.id}`));
+    console.log(chalk.white(`  Nome: ${db.name}`));
+    console.log(chalk.white(`  Tipo: ${db.type}`));
+
+    const statusColor = db.status === 'running' ? chalk.green : chalk.gray;
+    console.log(`  Status: ${statusColor(db.status)}`);
+
+    console.log(chalk.cyan(`  Host: ${db.host}`));
+    console.log(chalk.white(`  Porta: ${db.port}`));
+    console.log(chalk.white(`  Database: ${db.database_name}`));
+    console.log(chalk.white(`  Username: ${db.username}`));
+    console.log(chalk.yellow(`  Password: ${db.password}`));
+    console.log(chalk.yellow(`  💰 Custo: ${db.cost} coins/dia`));
+
+    if (db.containers && db.containers.length > 0) {
+      console.log(chalk.gray('\n📦 Containers vinculados:'));
+      db.containers.forEach(c => {
+        console.log(chalk.white(`  • ${c.name} ${chalk.gray(`(${c.id})`)}`));
+      });
+    }
+
+    console.log(chalk.gray(`\n📅 Criado em: ${new Date(db.created_at).toLocaleString('pt-BR')}`));
+    console.log(chalk.gray(`   Atualizado em: ${new Date(db.updated_at).toLocaleString('pt-BR')}`));
+
+    console.log(chalk.gray('\n🔗 Connection String:'));
+    console.log(chalk.cyan(`  ${db.connection_string}`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao buscar informações:'));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
+    process.exit(1);
+  }
+}
+
+// ============================================
+// CREDENTIALS - Ver credenciais do database
+// ============================================
+async function credentials(identifier) {
+  try {
+    const spinner = ora('Carregando credenciais...').start();
+    const database = await resolveDatabase(identifier);
+
+    const response = await api.getDatabase(database.id);
+    spinner.stop();
+
+    const db = response.database;
+
+    console.log(chalk.cyan.bold(`\n🔑 Credenciais de ${db.name}\n`));
+    console.log(chalk.white(`  Host: ${chalk.cyan(db.host)}`));
+    console.log(chalk.white(`  Porta: ${chalk.cyan(db.port)}`));
+    console.log(chalk.white(`  Database: ${chalk.cyan(db.database_name)}`));
+    console.log(chalk.white(`  Username: ${chalk.cyan(db.username)}`));
+    console.log(chalk.white(`  Password: ${chalk.yellow(db.password)}`));
+
+    console.log(chalk.gray('\n🔗 Connection String:'));
+    console.log(chalk.cyan(`  ${db.connection_string}`));
+
+    console.log(chalk.gray('\n💡 Copie e cole em suas variáveis de ambiente'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao buscar credenciais:'));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
+    process.exit(1);
+  }
+}
+
+// ============================================
+// LINK - Vincular database a container
+// ============================================
+async function link(databaseIdentifier, containerIdentifier) {
+  try {
+    if (!containerIdentifier) {
+      console.error(chalk.red('❌ Container não especificado'));
+      console.log(chalk.gray('   Use: mozhost db:link <database> <container>'));
+      process.exit(1);
+    }
+
+    const spinner = ora('Resolvendo database...').start();
+    const database = await resolveDatabase(databaseIdentifier);
+
+    spinner.text = 'Resolvendo container...';
+    // Reusar a função de containers (você precisará exportá-la ou criar similar)
+    let containerId;
+    try {
+      const containerResponse = await api.getContainer(containerIdentifier);
+      containerId = containerResponse.container.id;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        const listResponse = await api.listContainers();
+        const found = listResponse.containers.find(c =>
+          c.name === containerIdentifier ||
+          c.id === containerIdentifier ||
+          c.id.startsWith(containerIdentifier)
+        );
+        if (!found) {
+          throw new Error(`Container "${containerIdentifier}" não encontrado`);
+        }
+        containerId = found.id;
+      } else {
+        throw error;
+      }
+    }
+
+    spinner.text = 'Vinculando database ao container...';
+    await api.linkDatabase(database.id, containerId);
+
+    spinner.succeed(chalk.green(`✅ Database ${database.name} vinculado com sucesso!`));
+
+    console.log(chalk.gray('\n💡 O container agora pode acessar este database'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao vincular database:'));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
+    process.exit(1);
+  }
+}
+
+// ============================================
+// DELETE - Deletar database
+// ============================================
+async function deleteDatabase(identifier) {
+  try {
+    const spinner = ora('Resolvendo database...').start();
+    const database = await resolveDatabase(identifier);
+    spinner.stop();
+
+    console.log(chalk.yellow('\n⚠️  ATENÇÃO: Esta ação é irreversível!'));
+    console.log(chalk.gray('   Todos os dados serão perdidos permanentemente.\n'));
+
+    const confirm = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: chalk.red(`Tem certeza que deseja deletar "${database.name}"?`),
+        default: false
+      }
+    ]);
+
+    if (!confirm.confirmed) {
+      console.log(chalk.yellow('Operação cancelada'));
+      return;
+    }
+
+    // Confirmação dupla para databases
+    const doubleConfirm = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'typed',
+        message: chalk.red(`Digite o nome do database "${database.name}" para confirmar:`),
+      }
+    ]);
+
+    if (doubleConfirm.typed !== database.name) {
+      console.log(chalk.red('❌ Nome incorreto. Operação cancelada.'));
+      return;
+    }
+
+    const deleteSpinner = ora(`Deletando ${database.name}...`).start();
+    await api.deleteDatabase(database.id);
+
+    deleteSpinner.succeed(chalk.green(`✅ Database ${database.name} deletado com sucesso!`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao deletar database:'));
+    console.error(chalk.red(`   ${error.message || error.response?.data?.error}`));
+    process.exit(1);
+  }
+}
+
+// ============================================
+// EXPORTS
+// ============================================
+module.exports = {
+  list,
+  create,
+  info,
+  credentials,
+  link,
+  deleteDatabase
+};

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);

package/src/utils/api.js

@@ -170,4 +170,37 @@ class ApiClient {
   }
 }
 
+  // Databases
+  async listDatabases() {
+    const client = await this.getClient();
+    const response = await client.get('/api/databases');
+    return response.data;
+  }
+
+  async getDatabase(databaseId) {
+    const client = await this.getClient();
+    const response = await client.get(`/api/databases/${databaseId}`);
+    return response.data;
+  }
+
+  async createDatabase(data) {
+    const client = await this.getClient();
+    const response = await client.post('/api/databases', data);
+    return response.data;
+  }
+
+  async deleteDatabase(databaseId) {
+    const client = await this.getClient();
+    const response = await client.delete(`/api/databases/${databaseId}`);
+    return response.data;
+  }
+
+  async linkDatabase(databaseId, containerId) {
+    const client = await this.getClient();
+    const response = await client.post(`/api/databases/${databaseId}/link`, {
+      container_id: containerId
+    });
+    return response.data;
+  }
+
 module.exports = new ApiClient();