mozhost-cli 1.0.0

package/bin/mozhost.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const authCommands = require('../src/commands/auth');
+const containerCommands = require('../src/commands/containers');
+const deployCommands = require('../src/commands/deploy');
+const packageJson = require('../package.json');
+
+program
+  .name('mozhost')
+  .description('CLI for MozHost - Hospedagem de Bots e APIs')
+  .version(packageJson.version);
+
+// Auth commands
+program
+  .command('auth')
+  .description('Autenticar na MozHost')
+  .action(authCommands.login);
+
+program
+  .command('logout')
+  .description('Deslogar da MozHost')
+  .action(authCommands.logout);
+
+program
+  .command('whoami')
+  .description('Ver usuário atual')
+  .action(authCommands.whoami);
+
+// Container commands
+program
+  .command('containers')
+  .alias('ls')
+  .description('Listar containers')
+  .action(containerCommands.list);
+
+program
+  .command('create')
+  .description('Criar novo container')
+  .requiredOption('-n, --name <name>', 'Nome do container')
+  .requiredOption('-t, --type <type>', 'Tipo (nodejs, python, php)')
+  .action(containerCommands.create);
+
+program
+  .command('start <container>')
+  .description('Iniciar container')
+  .action(containerCommands.start);
+
+program
+  .command('stop <container>')
+  .description('Parar container')
+  .action(containerCommands.stop);
+
+program
+  .command('restart <container>')
+  .description('Reiniciar container')
+  .action(containerCommands.restart);
+
+program
+  .command('delete <container>')
+  .alias('rm')
+  .description('Deletar container')
+  .action(containerCommands.deleteContainer);
+
+program
+  .command('logs <container>')
+  .description('Ver logs do container')
+  .option('-n, --lines <number>', 'Número de linhas', '100')
+  .action(containerCommands.logs);
+
+program
+  .command('info <container>')
+  .description('Ver informações do container')
+  .action(containerCommands.info);
+
+program
+  .command('url <container>')
+  .description('Ver URL do container')
+  .action(containerCommands.url);
+
+// Deploy commands
+program
+  .command('init')
+  .description('Inicializar projeto para deploy')
+  .action(deployCommands.init);
+
+program
+  .command('deploy [container]')
+  .description('Fazer deploy do projeto atual')
+  .option('-d, --directory <path>', 'Diretório do projeto', '.')
+  .action(deployCommands.deploy);
+
+program
+  .command('link <container>')
+  .description('Vincular diretório atual a um container')
+  .action(deployCommands.link);
+
+// Parse arguments
+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();
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "mozhost-cli",
+  "version": "1.0.0",
+  "description": "Command-line interface for MozHost container platform",
+  "main": "index.js",
+  "bin": {
+    "mozhost": "./bin/mozhost.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mozhost",
+    "cli",
+    "containers",
+    "docker",
+    "deployment"
+  ],
+  "author": "Eliobros Tech",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.5",
+    "form-data": "^4.0.0",
+    "archiver": "^6.0.1",
+    "fs-extra": "^11.1.1",
+    "dotenv": "^16.3.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/src/commands/auth.js

@@ -0,0 +1,122 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const api = require('../utils/api');
+const config = require('../utils/config');
+
+async function login() {
+  console.log(chalk.cyan.bold('\n🔐 MozHost - Login\n'));
+
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'login',
+        message: 'Username ou Email:',
+        validate: input => input.length > 0 || 'Campo obrigatório'
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Password:',
+        mask: '*',
+        validate: input => input.length > 0 || 'Campo obrigatório'
+      }
+    ]);
+
+    const spinner = ora('Autenticando...').start();
+
+    const response = await api.login(answers);
+
+    await config.setToken(response.token);
+    await config.setUser(response.user);
+
+    spinner.succeed(chalk.green('✅ Login realizado com sucesso!'));
+    
+    console.log(chalk.gray('\nInformações da conta:'));
+    console.log(chalk.white(`  Username: ${response.user.username}`));
+    console.log(chalk.white(`  Email: ${response.user.email}`));
+    console.log(chalk.white(`  Plano: ${response.user.plan}`));
+    console.log(chalk.white(`  Containers: ${response.user.maxContainers}`));
+    console.log(chalk.yellow(`  Coins: ${response.user.coins || 0}`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro no login:'));
+    
+    if (error.response) {
+      console.error(chalk.red(`   ${error.response.data.error || error.response.data.message}`));
+    } else if (error.request) {
+      console.error(chalk.red('   Não foi possível conectar à API'));
+    } else {
+      console.error(chalk.red(`   ${error.message}`));
+    }
+    
+    process.exit(1);
+  }
+}
+
+async function logout() {
+  try {
+    const user = await config.getUser();
+    
+    if (!user) {
+      console.log(chalk.yellow('⚠️  Você não está logado'));
+      return;
+    }
+
+    await config.clearToken();
+    console.log(chalk.green('✅ Logout realizado com sucesso!'));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Erro ao fazer logout:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function whoami() {
+  try {
+    const token = await config.getToken();
+    
+    if (!token) {
+      console.log(chalk.yellow('⚠️  Você não está logado'));
+      console.log(chalk.gray('   Use: mozhost auth'));
+      return;
+    }
+
+    const spinner = ora('Verificando credenciais...').start();
+    
+    const response = await api.verify();
+    
+    spinner.stop();
+
+    console.log(chalk.cyan.bold('\n👤 Usuário Atual\n'));
+    console.log(chalk.white(`  Username: ${response.user.username}`));
+    console.log(chalk.white(`  Email: ${response.user.email}`));
+    console.log(chalk.white(`  Plano: ${response.user.plan}`));
+    console.log(chalk.white(`  Max Containers: ${response.user.maxContainers}`));
+    console.log(chalk.white(`  Max RAM: ${response.user.maxRamMb}MB`));
+    console.log(chalk.white(`  Max Storage: ${response.user.maxStorageMb}MB`));
+    console.log(chalk.yellow(`  Coins: ${response.user.coins || 0}`));
+    console.log(chalk.gray(`\n  Email Verificado: ${response.user.emailVerified ? '✓' : '✗'}`));
+    console.log(chalk.gray(`  WhatsApp Verificado: ${response.user.whatsappVerified ? '✓' : '✗'}`));
+    console.log(chalk.gray(`  SMS Verificado: ${response.user.smsVerified ? '✓' : '✗'}`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao verificar usuário:'));
+    
+    if (error.response?.status === 401) {
+      console.error(chalk.red('   Token inválido ou expirado'));
+      console.log(chalk.gray('   Use: mozhost auth'));
+    } else {
+      console.error(chalk.red(`   ${error.message}`));
+    }
+    
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  login,
+  logout,
+  whoami
+};

package/src/commands/containers.js

@@ -0,0 +1,269 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const api = require('../utils/api');
+
+async function list() {
+  try {
+    const spinner = ora('Carregando containers...').start();
+    
+    const response = await api.listContainers();
+    
+    spinner.stop();
+
+    if (response.containers.length === 0) {
+      console.log(chalk.yellow('\n⚠️  Nenhum container encontrado'));
+      console.log(chalk.gray('   Use: mozhost create -n <nome> -t <tipo>'));
+      return;
+    }
+
+    console.log(chalk.cyan.bold(`\n📦 Containers (${response.total})\n`));
+
+    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)}`);
+      console.log(`  ${chalk.gray('URL:')} ${chalk.cyan(`https://${container.domain}`)}`);
+      console.log(`  ${chalk.gray('Porta:')} ${container.port}`);
+      console.log(`  ${chalk.gray('RAM:')} ${container.memory_limit_mb}MB`);
+      console.log(`  ${chalk.gray('Storage:')} ${container.storage_used_mb || 0}MB\n`);
+    });
+
+    if (response.coins !== undefined) {
+      console.log(chalk.yellow(`💰 Coins disponíveis: ${response.coins}\n`));
+    }
+
+    if (response.storageAlerts?.length > 0) {
+      console.log(chalk.red('⚠️  Alertas de armazenamento:'));
+      response.storageAlerts.forEach(alert => {
+        console.log(chalk.red(`   ${alert.name}: ${alert.usedMB}MB / ${alert.maxMB}MB (>90%)`));
+      });
+      console.log();
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao listar containers:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function create(options) {
+  try {
+    const { name, type } = options;
+
+    if (!['nodejs', 'python', 'php'].includes(type)) {
+      console.error(chalk.red('❌ Tipo inválido. Use: nodejs, python ou php'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan.bold('\n🔨 Criando container...\n'));
+    console.log(chalk.gray(`  Nome: ${name}`));
+    console.log(chalk.gray(`  Tipo: ${type}\n`));
+
+    const spinner = ora('Criando container...').start();
+
+    const response = await api.createContainer({ name, type });
+
+    spinner.succeed(chalk.green('✅ Container criado com sucesso!'));
+
+    console.log(chalk.gray('\nInformações do container:'));
+    console.log(chalk.white(`  ID: ${response.container.id}`));
+    console.log(chalk.white(`  Nome: ${response.container.name}`));
+    console.log(chalk.white(`  Tipo: ${response.container.type}`));
+    console.log(chalk.white(`  Status: ${response.container.status}`));
+    console.log(chalk.cyan(`  URL: https://${response.container.domain}`));
+    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}`));
+
+  } 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) {
+  try {
+    const spinner = ora('Iniciando container...').start();
+    
+    const response = await api.startContainer(containerId);
+    
+    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}`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao iniciar container:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function stop(containerId) {
+  try {
+    const spinner = ora('Parando container...').start();
+    
+    const response = await api.stopContainer(containerId);
+    
+    spinner.succeed(chalk.green(`✅ Container ${response.container.name} parado!`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao parar container:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function restart(containerId) {
+  try {
+    const spinner = ora('Reiniciando container...').start();
+    
+    const response = await api.restartContainer(containerId);
+    
+    spinner.succeed(chalk.green(`✅ Container ${response.container.name} reiniciado!`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao reiniciar container:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function deleteContainer(containerId) {
+  try {
+    const confirm = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: chalk.red('Tem certeza que deseja deletar este container?'),
+        default: false
+      }
+    ]);
+
+    if (!confirm.confirmed) {
+      console.log(chalk.yellow('Operação cancelada'));
+      return;
+    }
+
+    const spinner = ora('Deletando container...').start();
+    
+    await api.deleteContainer(containerId);
+    
+    spinner.succeed(chalk.green('✅ Container deletado com sucesso!'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao deletar container:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function logs(containerId, options) {
+  try {
+    const spinner = ora('Carregando logs...').start();
+    
+    const response = await api.getContainerLogs(containerId, options.lines);
+    
+    spinner.stop();
+
+    if (!response.logs || response.logs.length === 0) {
+      console.log(chalk.yellow('\n⚠️  Nenhum log encontrado'));
+      return;
+    }
+
+    console.log(chalk.cyan.bold('\n📝 Logs do Container\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}`));
+    process.exit(1);
+  }
+}
+
+async function info(containerId) {
+  try {
+    const spinner = ora('Carregando informações...').start();
+    
+    const response = await api.getContainer(containerId);
+    
+    spinner.stop();
+
+    const container = 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')}`));
+
+    if (response.stats) {
+      console.log(chalk.cyan.bold('\n📊 Estatísticas em Tempo Real\n'));
+      console.log(chalk.white(`  CPU: ${response.stats.cpu.toFixed(2)}%`));
+      console.log(chalk.white(`  Memória: ${(response.stats.memory.used / 1024 / 1024).toFixed(2)}MB / ${(response.stats.memory.limit / 1024 / 1024).toFixed(2)}MB (${response.stats.memory.percent.toFixed(2)}%)`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao buscar informações:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function url(containerId) {
+  try {
+    const response = await api.getContainer(containerId);
+    console.log(chalk.cyan(`https://${response.container.domain}`));
+  } catch (error) {
+    console.error(chalk.red('❌ Erro ao buscar URL:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  list,
+  create,
+  start,
+  stop,
+  restart,
+  deleteContainer,
+  logs,
+  info,
+  url
+};

package/src/commands/deploy.js

@@ -0,0 +1,303 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const archiver = require('archiver');
+const FormData = require('form-data');
+const api = require('../utils/api');
+const config = require('../utils/config');
+
+// Arquivos/pastas ignorados por padrão
+const DEFAULT_IGNORE = [
+  'node_modules',
+  '.git',
+  '.env',
+  '.DS_Store',
+  'dist',
+  'build',
+  '.mozhost.json',
+  '*.log',
+  '.vscode',
+  '.idea',
+  '__pycache__',
+  '*.pyc',
+  'venv',
+  'env'
+];
+
+async function init() {
+  try {
+    console.log(chalk.cyan.bold('\n🚀 Inicializar Deploy MozHost\n'));
+
+    // Verificar se já existe configuração
+    const existingConfig = await config.getProjectConfig();
+    if (existingConfig) {
+      console.log(chalk.yellow('⚠️  Projeto já inicializado'));
+      console.log(chalk.gray(`   Container vinculado: ${existingConfig.name} (${existingConfig.container})`));
+      
+      const { override } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'override',
+          message: 'Deseja reconfigurar?',
+          default: false
+        }
+      ]);
+
+      if (!override) {
+        return;
+      }
+    }
+
+    // Listar containers disponíveis
+    const spinner = ora('Carregando containers...').start();
+    const response = await api.listContainers();
+    spinner.stop();
+
+    if (response.containers.length === 0) {
+      console.log(chalk.red('\n❌ Nenhum container encontrado'));
+      console.log(chalk.gray('   Crie um container primeiro: mozhost create -n <nome> -t <tipo>'));
+      return;
+    }
+
+    // Selecionar container
+    const { containerId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'containerId',
+        message: 'Selecione o container:',
+        choices: response.containers.map(c => ({
+          name: `${c.name} (${c.type}) - ${c.status}`,
+          value: c.id
+        }))
+      }
+    ]);
+
+    const selectedContainer = response.containers.find(c => c.id === containerId);
+
+    // Criar arquivo .mozhostignore se não existir
+    const ignorePath = path.join(process.cwd(), '.mozhostignore');
+    if (!fs.existsSync(ignorePath)) {
+      await fs.writeFile(ignorePath, DEFAULT_IGNORE.join('\n'));
+      console.log(chalk.green('✅ Arquivo .mozhostignore criado'));
+    }
+
+    // Salvar configuração
+    await config.linkContainer(containerId, selectedContainer.name);
+
+    console.log(chalk.green('\n✅ Projeto inicializado com sucesso!'));
+    console.log(chalk.gray(`   Container: ${selectedContainer.name}`));
+    console.log(chalk.cyan(`   URL: https://${selectedContainer.domain}`));
+    console.log(chalk.gray('\nPróximos passos:'));
+    console.log(chalk.white('   mozhost deploy'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao inicializar:'));
+    console.error(chalk.red(`   ${error.message}`));
+    process.exit(1);
+  }
+}
+
+async function link(containerId) {
+  try {
+    console.log(chalk.cyan.bold('\n🔗 Vincular Container\n'));
+
+    const spinner = ora('Buscando container...').start();
+    
+    const response = await api.getContainer(containerId);
+    const container = response.container;
+    
+    spinner.stop();
+
+    await config.linkContainer(container.id, container.name);
+
+    console.log(chalk.green('✅ Container vinculado com sucesso!'));
+    console.log(chalk.gray(`   Container: ${container.name}`));
+    console.log(chalk.cyan(`   URL: https://${container.domain}`));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro ao vincular container:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function deploy(containerId, options) {
+  try {
+    const projectDir = path.resolve(options.directory);
+
+    if (!fs.existsSync(projectDir)) {
+      console.error(chalk.red(`❌ Diretório não encontrado: ${projectDir}`));
+      process.exit(1);
+    }
+
+    // Determinar container ID
+    let targetContainerId = containerId;
+    
+    if (!targetContainerId) {
+      targetContainerId = await config.getLinkedContainer();
+      
+      if (!targetContainerId) {
+        console.error(chalk.red('❌ Nenhum container especificado'));
+        console.log(chalk.gray('   Use: mozhost deploy <container-id>'));
+        console.log(chalk.gray('   Ou: mozhost init (para vincular)'));
+        process.exit(1);
+      }
+    }
+
+    console.log(chalk.cyan.bold('\n🚀 Deploy MozHost\n'));
+
+    // Buscar informações do container
+    const spinner = ora('Verificando container...').start();
+    const containerInfo = await api.getContainer(targetContainerId);
+    spinner.text = 'Empacotando arquivos...';
+
+    // Ler arquivos ignorados
+    const ignorePatterns = await getIgnorePatterns(projectDir);
+
+    // Coletar arquivos
+    const files = await collectFiles(projectDir, ignorePatterns);
+
+    if (files.length === 0) {
+      spinner.fail(chalk.red('Nenhum arquivo encontrado para deploy'));
+      process.exit(1);
+    }
+
+    spinner.text = `Fazendo upload de ${files.length} arquivos...`;
+
+    // Fazer upload dos arquivos
+    await uploadFiles(targetContainerId, projectDir, files, spinner);
+
+    spinner.succeed(chalk.green('✅ Deploy concluído com sucesso!'));
+
+    console.log(chalk.gray(`\n📦 Arquivos enviados: ${files.length}`));
+    console.log(chalk.cyan(`🌐 URL: https://${containerInfo.container.domain}`));
+
+    // Perguntar se quer iniciar o container
+    if (containerInfo.container.status !== 'running') {
+      const { startNow } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'startNow',
+          message: 'Container parado. Deseja iniciar agora?',
+          default: true
+        }
+      ]);
+
+      if (startNow) {
+        const startSpinner = ora('Iniciando container...').start();
+        await api.startContainer(targetContainerId);
+        startSpinner.succeed(chalk.green('✅ Container iniciado!'));
+      }
+    } else {
+      const { restart } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'restart',
+          message: 'Deseja reiniciar o container para aplicar as mudanças?',
+          default: true
+        }
+      ]);
+
+      if (restart) {
+        const restartSpinner = ora('Reiniciando container...').start();
+        await api.restartContainer(targetContainerId);
+        restartSpinner.succeed(chalk.green('✅ Container reiniciado!'));
+      }
+    }
+
+    console.log(chalk.gray('\n💡 Dica: Use "mozhost logs <container>" para ver os logs\n'));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Erro no deploy:'));
+    console.error(chalk.red(`   ${error.response?.data?.error || error.message}`));
+    process.exit(1);
+  }
+}
+
+async function getIgnorePatterns(projectDir) {
+  const ignorePath = path.join(projectDir, '.mozhostignore');
+  
+  if (fs.existsSync(ignorePath)) {
+    const content = await fs.readFile(ignorePath, 'utf-8');
+    return [...DEFAULT_IGNORE, ...content.split('\n').filter(line => line.trim() && !line.startsWith('#'))];
+  }
+  
+  return DEFAULT_IGNORE;
+}
+
+async function collectFiles(dir, ignorePatterns, baseDir = dir) {
+  const files = [];
+  const items = await fs.readdir(dir);
+
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    const relativePath = path.relative(baseDir, fullPath);
+
+    // Verificar se deve ignorar
+    if (shouldIgnore(relativePath, ignorePatterns)) {
+      continue;
+    }
+
+    const stat = await fs.stat(fullPath);
+
+    if (stat.isDirectory()) {
+      const subFiles = await collectFiles(fullPath, ignorePatterns, baseDir);
+      files.push(...subFiles);
+    } else if (stat.isFile()) {
+      files.push(relativePath);
+    }
+  }
+
+  return files;
+}
+
+function shouldIgnore(filePath, patterns) {
+  const normalized = filePath.replace(/\\/g, '/');
+  
+  return patterns.some(pattern => {
+    // Pattern exato
+    if (normalized === pattern || normalized.startsWith(pattern + '/')) {
+      return true;
+    }
+    
+    // Wildcard simples
+    if (pattern.includes('*')) {
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return regex.test(normalized);
+    }
+    
+    return false;
+  });
+}
+
+async function uploadFiles(containerId, projectDir, files, spinner) {
+  const client = await api.getClient();
+  const baseURL = await config.getApiUrl();
+
+  // Enviar em lotes para evitar timeout
+  const BATCH_SIZE = 20;
+  
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    
+    spinner.text = `Upload: ${Math.min(i + BATCH_SIZE, files.length)}/${files.length} arquivos...`;
+
+    for (const file of batch) {
+      const fullPath = path.join(projectDir, file);
+      const content = await fs.readFile(fullPath, 'utf-8');
+
+      await client.post(`${baseURL}/api/files/${containerId}`, {
+        path: file,
+        content: content
+      });
+    }
+  }
+}
+
+module.exports = {
+  init,
+  link,
+  deploy
+};

package/src/utils/api.js

@@ -0,0 +1,154 @@
+const axios = require('axios');
+const config = require('./config');
+const chalk = require('chalk');
+
+class ApiClient {
+  async getClient() {
+    const baseURL = await config.getApiUrl();
+    const token = await config.getToken();
+
+    const client = axios.create({
+      baseURL,
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // Add auth token if available
+    if (token) {
+      client.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    }
+
+    // Response interceptor for error handling
+    client.interceptors.response.use(
+      response => response,
+      async error => {
+        if (error.response?.status === 401) {
+          console.error(chalk.red('❌ Não autenticado. Use: mozhost auth'));
+          await config.clearToken();
+          process.exit(1);
+        }
+        throw error;
+      }
+    );
+
+    return client;
+  }
+
+  // Auth
+  async login(credentials) {
+    const client = await this.getClient();
+    const response = await client.post('/api/auth/login', credentials);
+    return response.data;
+  }
+
+  async verify() {
+    const client = await this.getClient();
+    const response = await client.get('/api/auth/verify');
+    return response.data;
+  }
+
+  // Containers
+  async listContainers() {
+    const client = await this.getClient();
+    const response = await client.get('/api/containers');
+    return response.data;
+  }
+
+  async getContainer(containerId) {
+    const client = await this.getClient();
+    const response = await client.get(`/api/containers/${containerId}`);
+    return response.data;
+  }
+
+  async createContainer(data) {
+    const client = await this.getClient();
+    const response = await client.post('/api/containers', data);
+    return response.data;
+  }
+
+  async startContainer(containerId) {
+    const client = await this.getClient();
+    const response = await client.post(`/api/containers/${containerId}/start`);
+    return response.data;
+  }
+
+  async stopContainer(containerId) {
+    const client = await this.getClient();
+    const response = await client.post(`/api/containers/${containerId}/stop`);
+    return response.data;
+  }
+
+  async restartContainer(containerId) {
+    const client = await this.getClient();
+    const response = await client.post(`/api/containers/${containerId}/restart`);
+    return response.data;
+  }
+
+  async deleteContainer(containerId) {
+    const client = await this.getClient();
+    const response = await client.delete(`/api/containers/${containerId}`);
+    return response.data;
+  }
+
+  async getContainerLogs(containerId, tail = 100) {
+    const client = await this.getClient();
+    const response = await client.get(`/api/containers/${containerId}/logs`, {
+      params: { tail }
+    });
+    return response.data;
+  }
+
+  // Files
+  async listFiles(containerId, dirPath = '/') {
+    const client = await this.getClient();
+    const response = await client.get(`/api/files/${containerId}`, {
+      params: { path: dirPath }
+    });
+    return response.data;
+  }
+
+  async uploadFile(containerId, filePath, content) {
+    const client = await this.getClient();
+    const response = await client.post(`/api/files/${containerId}`, {
+      path: filePath,
+      content
+    });
+    return response.data;
+  }
+
+  async uploadFiles(containerId, files) {
+    const client = await this.getClient();
+    const FormData = require('form-data');
+    const form = new FormData();
+
+    for (const file of files) {
+      form.append('files', file.content, {
+        filename: file.path,
+        filepath: file.path
+      });
+    }
+
+    const response = await client.post(
+      `/api/files/${containerId}/upload`,
+      form,
+      {
+        headers: form.getHeaders(),
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+    );
+    return response.data;
+  }
+
+  async deleteFile(containerId, filePath) {
+    const client = await this.getClient();
+    const response = await client.delete(`/api/files/${containerId}`, {
+      data: { path: filePath }
+    });
+    return response.data;
+  }
+}
+
+module.exports = new ApiClient();

package/src/utils/config.js

@@ -0,0 +1,114 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.mozhost');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const PROJECT_CONFIG = '.mozhost.json';
+
+class Config {
+  constructor() {
+    this.ensureConfigDir();
+  }
+
+  ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  }
+
+  // Configuração global (token, API URL, etc)
+  async getGlobalConfig() {
+    try {
+      if (fs.existsSync(CONFIG_FILE)) {
+        return await fs.readJson(CONFIG_FILE);
+      }
+      return {};
+    } catch (error) {
+      return {};
+    }
+  }
+
+  async setGlobalConfig(config) {
+    await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+  }
+
+  async updateGlobalConfig(updates) {
+    const current = await this.getGlobalConfig();
+    await this.setGlobalConfig({ ...current, ...updates });
+  }
+
+  async getToken() {
+    const config = await this.getGlobalConfig();
+    return config.token || null;
+  }
+
+  async setToken(token) {
+    await this.updateGlobalConfig({ token });
+  }
+
+  async clearToken() {
+    const config = await this.getGlobalConfig();
+    delete config.token;
+    delete config.user;
+    await this.setGlobalConfig(config);
+  }
+
+  async getApiUrl() {
+    const config = await this.getGlobalConfig();
+    return config.apiUrl || process.env.MOZHOST_API_URL || 'https://api.mozhost.topaziocoin.online';
+  }
+
+  async setApiUrl(apiUrl) {
+    await this.updateGlobalConfig({ apiUrl });
+  }
+
+  async getUser() {
+    const config = await this.getGlobalConfig();
+    return config.user || null;
+  }
+
+  async setUser(user) {
+    await this.updateGlobalConfig({ user });
+  }
+
+  // Configuração do projeto local
+  async getProjectConfig() {
+    try {
+      const projectConfigPath = path.join(process.cwd(), PROJECT_CONFIG);
+      if (fs.existsSync(projectConfigPath)) {
+        return await fs.readJson(projectConfigPath);
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async setProjectConfig(config) {
+    const projectConfigPath = path.join(process.cwd(), PROJECT_CONFIG);
+    await fs.writeJson(projectConfigPath, config, { spaces: 2 });
+  }
+
+  async getLinkedContainer() {
+    const projectConfig = await this.getProjectConfig();
+    return projectConfig?.container || null;
+  }
+
+  async linkContainer(containerId, containerName) {
+    await this.setProjectConfig({
+      container: containerId,
+      name: containerName,
+      linkedAt: new Date().toISOString()
+    });
+  }
+
+  async unlinkContainer() {
+    const projectConfigPath = path.join(process.cwd(), PROJECT_CONFIG);
+    if (fs.existsSync(projectConfigPath)) {
+      await fs.remove(projectConfigPath);
+    }
+  }
+}
+
+module.exports = new Config();