smoonb 0.0.55 → 0.0.57

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Goalmoon Tecnologia Ltda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,32 +1,43 @@
-# smoonb
+# Supa Moonbase (smoonb)
 
 **Complete Supabase backup and migration tool**
 
-## ⚠️ EXPERIMENTAL VERSION - NÃO TESTADA - USE POR SUA CONTA E RISCO
+A primeira ferramenta CLI completa para backup e migração de projetos Supabase. Resolve o problema de backup incompleto das ferramentas existentes.
 
-**🚨 AVISO IMPORTANTE:**
-- Este software **NUNCA** foi testado em produção
-- **USE POR SUA CONTA E RISCO** - Pode causar perda irreparável de dados
-- **NÃO NOS RESPONSABILIZAMOS** por qualquer perda de dados
-- **NENHUM SUPORTE** é oferecido nesta fase - apenas aceitamos contribuições
+> **Nota sobre acesso comercial:** o Supa Moonbase passará a exigir validação de conta antes de executar operações (login + verificação de assinatura) em fase futura. Nesta versão, não há autenticação implementada — este README apenas apresenta a base legal/comercial. O uso operacional será regido pelos [Termos de Serviço](https://smoonb.com/terms) e pela [Política de Privacidade](https://smoonb.com/privacy).
 
-**Desenvolvido por:** Goalmoon Tecnologia LTDA (https://goalmoon.com)
+**Desenvolvido por:** Goalmoon Tecnologia LTDA  
+**Website:** https://smoonb.com  
+**GitHub:** https://github.com/almmello/smoonb
 
 ## 🎯 Objetivo
 
-O **smoonb** resolve o problema das ferramentas existentes que fazem backup apenas da database PostgreSQL, ignorando componentes críticos do Supabase:
+O **smoonb** resolve o problema das ferramentas existentes que fazem backup apenas da database PostgreSQL, ignorando componentes críticos do Supabase.
+
+## 📦 Componentes de Backup
 
-- ✅ **Database PostgreSQL** (backup completo via `pg_dumpall`, idêntico ao Dashboard)
-- ✅ **Database SQL Separado** (schema, data, roles em arquivos separados para troubleshooting)
+O smoonb faz backup completo de todos os componentes do seu projeto Supabase:
+
+- ✅ **Database PostgreSQL** (backup completo via `pg_dumpall` + SQL separados, idêntico ao Dashboard)
 - ✅ **Database Extensions and Settings** (extensões PostgreSQL e configurações)
+- ✅ **Custom Roles** (roles personalizados do PostgreSQL)
 - ✅ **Edge Functions** (download automático do servidor)
 - ✅ **Auth Settings** (configurações de autenticação via Management API)
 - ✅ **Storage Buckets** (metadados e configurações via Management API)
-- ✅ **Realtime Settings** (publicações e configurações capturadas interativamente)
-- ✅ **Custom Roles** (roles personalizados do PostgreSQL)
+- ✅ **Realtime Settings** (7 parâmetros capturados interativamente)
 - ✅ **Supabase .temp** (arquivos temporários do Supabase CLI)
 - ✅ **Migrations** (todas as migrations do projeto via `supabase migration fetch`)
 
+## ⚠️ Termo de Uso e Aviso de Risco
+
+Ao usar o smoonb, você reconhece e concorda que o smoonb é fornecido "NO ESTADO EM QUE SE ENCONTRA" ("AS IS") e "CONFORME DISPONIBILIDADE", sem garantias de qualquer natureza—expressas, implícitas ou legais—incluindo, sem limitação, garantias de comercialização, adequação a um fim específico e não violação, na máxima extensão permitida pela lei aplicável.
+
+Operações de backup e restauração envolvem riscos, os ambientes variam amplamente e não é possível prever ou validar todas as configurações dos usuários. Você é o único responsável por validar seu ambiente, manter cópias independentes e verificar os resultados antes de utilizá-los em produção.
+
+**Limitação de responsabilidade (PT-BR)** — Na máxima extensão permitida por lei, a Goalmoon, seus contribuidores e licenciadores não serão responsáveis por danos indiretos, incidentais, especiais, consequentes, exemplares ou punitivos (incluindo perda de dados, interrupção de negócios ou lucros cessantes) decorrentes do uso, incapacidade de uso, das operações de backup/restauração realizadas com, ou dos resultados gerados pelo smoonb.
+
+**Observação para consumidores no Brasil (PT-BR)** — Para consumidores brasileiros, este aviso não afasta direitos irrenunciáveis previstos no Código de Defesa do Consumidor (CDC); qualquer limitação aqui prevista só se aplica nos limites da lei e não impede a indenização obrigatória quando cabível.
+
 ## 🚀 Instalação
 
 **⚠️ IMPORTANTE: Instale APENAS localmente no projeto!**
@@ -96,18 +107,18 @@ touch .env.local
 
 ```env
 # URLs e Chaves do Supabase
-NEXT_PUBLIC_SUPABASE_URL=https://seu-project-id.supabase.co
-NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
-SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+NEXT_PUBLIC_SUPABASE_URL=[sua-supabase-url]
+NEXT_PUBLIC_SUPABASE_ANON_KEY=[sua-anon-key]
+SUPABASE_SERVICE_ROLE_KEY=e[sua-service-role]
 
 # Database Connection
-SUPABASE_DB_URL=postgresql://postgres:[senha]@db.seu-project-id.supabase.co:5432/postgres
+SUPABASE_DB_URL=postgresql://postgres:[sua-database-password]@db.[seu-project-id].supabase.co:5432/postgres
 
 # Identificação do Projeto
-SUPABASE_PROJECT_ID=seu-project-id
+SUPABASE_PROJECT_ID=[seu-project-id]
 
 # Personal Access Token (OBRIGATÓRIO para Management API)
-SUPABASE_ACCESS_TOKEN=sbp_1234567890abcdef1234567890abcdef
+SUPABASE_ACCESS_TOKEN=[seu-access-token]]
 
 # Diretório de Backups (opcional, padrão: ./backups)
 SMOONB_OUTPUT_DIR=./backups
@@ -131,10 +142,6 @@ Valor atual: https://abc123.supabase.co
 Este é o valor correto do projeto alvo? (S/n): S
 ```
 
-### Método Legado: `.smoonbrc` (DEPRECADO)
-
-⚠️ **Nota:** O arquivo `.smoonbrc` ainda é suportado para compatibilidade, mas é **recomendado migrar para `.env.local`**.
-
 ```bash
 npx smoonb config --init
 ```
@@ -157,21 +164,21 @@ npx smoonb backup
    - ⚡ Edge Functions (explicação sobre reset de link e download)
    - 📦 Storage (explicação sobre metadados)
    - 🔐 Auth Settings (explicação sobre configurações)
-   - 🔄 Realtime Settings (explicação sobre captura interativa)
+   - 🔄 Realtime Settings (explicação sobre captura interativa de 7 parâmetros)
    - 🗑️ Opções de limpeza (functions, .temp, migrations após backup)
 6. **Resumo de Configurações** - Mostra tudo que será feito
 7. **Confirmação Final** - Confirma antes de iniciar
 8. **Execução das Etapas:**
-   - 📊 1/11 - Backup Database via `pg_dumpall` (Docker)
-   - 📊 2/11 - Backup Database SQL separado (schema, data, roles)
-   - 🔧 3/11 - Backup Database Extensions and Settings
-   - 🔐 4/11 - Backup Auth Settings (se selecionado)
-   - 🔄 5/11 - Backup Realtime Settings (se selecionado)
-   - 📦 6/11 - Backup Storage (se selecionado)
-   - 👥 7/11 - Backup Custom Roles
-   - ⚡ 8/11 - Backup Edge Functions (se selecionado)
-   - 📁 9/11 - Backup Supabase .temp
-   - 📋 10/11 - Backup Migrations
+   - 📊 1/10 - Backup Database via `pg_dumpall` (Docker)
+   - 📊 2/10 - Backup Database SQL separado (schema, data, roles)
+   - 🔧 3/10 - Backup Database Extensions and Settings
+   - 🔐 4/10 - Backup Auth Settings (se selecionado)
+   - 🔄 5/10 - Backup Realtime Settings (se selecionado) - 7 parâmetros capturados interativamente
+   - 📦 6/10 - Backup Storage (se selecionado)
+   - 👥 7/10 - Backup Custom Roles
+   - ⚡ 8/10 - Backup Edge Functions (se selecionado)
+   - 📁 9/10 - Backup Supabase .temp (se selecionado)
+   - 📋 10/10 - Backup Migrations (se selecionado)
 
 **Resultado:**
 ```
@@ -259,8 +266,6 @@ npx smoonb functions push
 | `npx smoonb backup` | Backup completo interativo usando Docker |
 | `npx smoonb restore` | Restauração interativa usando psql (Docker) |
 | `npx smoonb check` | Verificação de integridade pós-restore |
-| `npx smoonb functions` | Gerenciar Edge Functions |
-| `npx smoonb config` | Configurar credenciais (legado) |
 
 ## 🏗️ Arquitetura Técnica
 
@@ -328,6 +333,14 @@ restore/
 #### Auth, Storage, Realtime
 - **Management API**: Usa Personal Access Token
 - **JSON Export**: Configurações exportadas como JSON
+- **Realtime Settings**: Captura interativa de 7 parâmetros:
+  1. Enable Realtime service
+  2. Allow public access
+  3. Database connection pool size
+  4. Max concurrent clients
+  5. Max events per second
+  6. Max presence events per second
+  7. Max payload size in KB
 - **Manual para alguns**: Alguns settings precisam ser aplicados manualmente por segurança
 
 ### Restore Strategy
@@ -471,28 +484,51 @@ Se houver problemas:
 - **Sem Dados Sensíveis**: Nenhum dado sensível é enviado para fora do seu ambiente
 - **Docker Isolado**: Operações de database via Docker (isolamento)
 
-## 📝 Licença
+## 💼 Modelo de Acesso e Assinatura
 
-**Versões 0.x.x**: Uso gratuito (experimental)  
-**Versões 1.0.0+**: Licença comercial (anúncio com 90 dias de antecedência)
+O código do Supa Moonbase é disponibilizado sob licença MIT (ver `LICENSE`). Em fase futura, a execução do CLI será vinculada a uma assinatura por conta, permitindo uso associado a uma conta válida. A validação de conta ocorrerá antes de qualquer operação sensível (ex.: backup e restore).
 
-Veja [LICENSE.md](LICENSE.md) para mais detalhes.
+Até que a validação esteja ativa, a ferramenta pode ser utilizada sem login.
 
-## 🤝 Contribuição
+Saiba mais em [Pricing](https://smoonb.com/pricing) e [FAQ Comercial](https://smoonb.com/faq).
 
-Contribuições são bem-vindas! Este é um projeto experimental e precisamos de feedback da comunidade.
+## 🎁 Grandfathering (conceito)
+
+Contas criadas durante o período inicial de disponibilização comercial poderão manter condições de acesso diferenciadas enquanto permanecerem ativas. O objetivo é reconhecer os primeiros usuários. Detalhes específicos constarão nos [Termos de Serviço](https://smoonb.com/terms) e no [Pricing](https://smoonb.com/pricing).
 
-## 📚 Versão
+## 🔒 Privacidade e LGPD (resumo)
 
-**Versão Atual:** 0.0.48
+O Supa Moonbase adota o princípio de minimização de dados. Quando a validação de conta estiver ativa, trataremos apenas informações estritamente necessárias para controle de acesso e faturamento (por exemplo, identificador de conta e contato). Os propósitos, bases legais e direitos do titular serão descritos na [Política de Privacidade](https://smoonb.com/privacy).
 
-## ☕ Apoie o Projeto
+## 📋 Termos de Serviço e Uso de Marca
+
+A licença de código (MIT) não substitui os Termos de Serviço que regerão o acesso operacional por conta e a validação de assinatura.
+
+"Supa Moonbase" e elementos de identidade visual são marcas da Goalmoon Tecnologia Ltda.; o uso de marca e assets de branding é restrito, conforme os [Termos de Serviço](https://smoonb.com/terms).
+
+## ❓ FAQ Comercial
+
+**Por que assinatura se o código é MIT?**
+
+> O código permanece aberto para auditoria e contribuições. O acesso operacional será condicionado à validação de conta, conforme Termos de Serviço.
+
+**O que significa grandfathering?**
+
+> Contas do período inicial poderão manter condições diferenciadas enquanto ativas; detalhes estarão nos Termos.
+
+
+
+## 📝 Licença
+
+O código do Supa Moonbase é disponibilizado sob licença MIT. Veja [LICENSE](LICENSE) para o texto completo da licença.
+
+## 🤝 Contribuição
+
+Contribuições são bem-vindas! Este é um projeto experimental e precisamos de feedback da comunidade.
 
-Se este projeto for útil para você, considere comprar um café:  
-[Compre um café](https://pag.ae/7Yj8QjQjQ)
 
 ---
 
 **Desenvolvido por:** Goalmoon Tecnologia LTDA  
-**Website:** https://goalmoon.com  
+**Website:** https://smoonb.com  
 **GitHub:** https://github.com/almmello/smoonb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,

package/src/commands/backup/index.js

@@ -2,7 +2,6 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
 const { ensureDir, writeJson } = require('../../utils/fsx');
-const { readConfig, validateFor } = require('../../utils/config');
 const { showBetaBanner } = require('../../utils/banner');
 const { getDockerVersion } = require('../../utils/docker');
 const { readEnvFile, writeEnvFile, backupEnvFile } = require('../../utils/env');
@@ -28,6 +27,18 @@ module.exports = async (options) => {
   showBetaBanner();
   
   try {
+    // Termo de uso e aviso de risco
+    console.log(chalk.yellow.bold('\n⚠️  TERMO DE USO E AVISO DE RISCO\n'));
+    console.log(chalk.white('Ao prosseguir, você reconhece e concorda que o smoonb é fornecido "NO ESTADO EM QUE SE ENCONTRA" ("AS IS") e "CONFORME DISPONIBILIDADE", sem garantias de qualquer natureza—expressas, implícitas ou legais—incluindo, sem limitação, garantias de comercialização, adequação a um fim específico e não violação, na máxima extensão permitida pela lei aplicável. Operações de backup e restauração envolvem riscos, os ambientes variam amplamente e não é possível prever ou validar todas as configurações dos usuários. Você é o único responsável por validar seu ambiente, manter cópias independentes e verificar os resultados antes de utilizá-los em produção. O smoonb é construído com repositórios públicos, auditáveis e software livre, para auxiliar pessoas a simplificar seus fluxos, sem com isso criar qualquer garantia, promessa de suporte ou compromisso de nível de serviço.\n'));
+    console.log(chalk.white('Limitação de responsabilidade (PT-BR) — Na máxima extensão permitida por lei, a Goalmoon, seus contribuidores e licenciadores não serão responsáveis por danos indiretos, incidentais, especiais, consequentes, exemplares ou punitivos (incluindo perda de dados, interrupção de negócios ou lucros cessantes) decorrentes do uso, incapacidade de uso, das operações de backup/restauração realizadas com, ou dos resultados gerados pelo smoonb. Em qualquer hipótese, a responsabilidade total por todas as reivindicações relacionadas ao smoonb não excederá o valor pago por você pelo smoonb nos 12 meses anteriores ao evento. Nada neste aviso exclui ou limita responsabilidades onde tais limites sejam proibidos por lei, incluindo (conforme aplicável) dolo ou culpa grave.\n'));
+    console.log(chalk.white('Observação para consumidores no Brasil (PT-BR) — Para consumidores brasileiros, este aviso não afasta direitos irrenunciáveis previstos no Código de Defesa do Consumidor (CDC); qualquer limitação aqui prevista só se aplica nos limites da lei e não impede a indenização obrigatória quando cabível.\n'));
+    
+    const termsAccepted = await confirm('Você aceita os Termos de Uso e o Aviso de Risco de Backup?', true);
+    if (!termsAccepted) {
+      console.log(chalk.red('🚫 Operação cancelada pelo usuário.'));
+      process.exit(1);
+    }
+
     // Executar validação Docker ANTES de tudo
     await step00DockerValidation();
 
@@ -42,9 +53,8 @@ module.exports = async (options) => {
       process.exit(1);
     }
 
-    // Carregar configuração existente apenas para defaults de diretório
-    const config = await readConfig().catch(() => ({ backup: { outputDir: './backups' }, supabase: {} }));
-    validateFor(config, 'backup');
+    // Diretório de backup padrão
+    const defaultOutputDir = './backups';
 
     // Pré-passo de ENV: criar diretório de backup com timestamp já no início
     const now = new Date();
@@ -56,7 +66,7 @@ module.exports = async (options) => {
     const second = String(now.getSeconds()).padStart(2, '0');
 
     // Resolver diretório de saída
-    const defaultOutput = options.output || config.backup?.outputDir || './backups';
+    const defaultOutput = options.output || defaultOutputDir;
     const backupDir = path.join(defaultOutput, `backup-${year}-${month}-${day}-${hour}-${minute}-${second}`);
     await ensureDir(backupDir);
 
@@ -88,7 +98,7 @@ module.exports = async (options) => {
     }
 
     // Recalcular outputDir a partir do ENV mapeado
-    const resolvedOutputDir = options.output || getValue('SMOONB_OUTPUT_DIR') || config.backup?.outputDir || './backups';
+    const resolvedOutputDir = options.output || getValue('SMOONB_OUTPUT_DIR') || defaultOutputDir;
 
     // Se mudou o outputDir, movemos o backupDir inicial para o novo local mantendo timestamp
     const finalBackupDir = backupDir.startsWith(path.resolve(resolvedOutputDir))
@@ -139,22 +149,22 @@ module.exports = async (options) => {
 
     // Mostrar resumo e pedir confirmação final
     console.log(chalk.cyan('\n📋 RESUMO DAS CONFIGURAÇÕES:\n'));
-    console.log(chalk.gray(`   ✅ Edge Functions: ${flags.includeFunctions ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Edge Functions: ${flags.includeFunctions ? 'Sim' : 'Não'}`));
     if (flags.includeFunctions) {
-      console.log(chalk.gray(`      🗑️  Limpar após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Limpar após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Supabase .temp: ${flags.includeTemp ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Supabase .temp: ${flags.includeTemp ? 'Sim' : 'Não'}`));
     if (flags.includeTemp) {
-      console.log(chalk.gray(`      🗑️  Apagar após backup: ${flags.cleanTemp ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Apagar após backup: ${flags.cleanTemp ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Migrations: ${flags.includeMigrations ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Migrations: ${flags.includeMigrations ? 'Sim' : 'Não'}`));
     if (flags.includeMigrations) {
-      console.log(chalk.gray(`      🗑️  Apagar após backup: ${flags.cleanMigrations ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Apagar após backup: ${flags.cleanMigrations ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Storage: ${flags.includeStorage ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   ✅ Auth: ${flags.includeAuth ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   ✅ Realtime: ${flags.includeRealtime ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   📁 Diretório de backup: ${finalBackupDir}\n`));
+    console.log(chalk.white(`   ✅ Storage: ${flags.includeStorage ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Auth: ${flags.includeAuth ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Realtime: ${flags.includeRealtime ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   📁 Diretório de backup: ${finalBackupDir}\n`));
 
     const finalOk = await confirm('Deseja iniciar o backup com estas configurações?', true);
 
@@ -193,7 +203,7 @@ module.exports = async (options) => {
 
     // Executar todas as etapas na ordem
     console.log(chalk.blue(`📁 Diretório: ${finalBackupDir}`));
-    console.log(chalk.gray(`🐳 Backup via Docker Desktop`));
+    console.log(chalk.white(`🐳 Backup via Docker Desktop`));
 
     // Contar etapas totais para numeração
     // Etapas fixas: Database, Database Separado, Database Settings, Custom Roles (4)

package/src/commands/backup/steps/00-docker-validation.js

@@ -17,7 +17,7 @@ module.exports = async () => {
   }
   
   console.log(chalk.green('✅ Docker Desktop detectado e funcionando'));
-  console.log(chalk.gray(`🐳 Versão: ${backupCapability.dockerStatus.version}`));
+  console.log(chalk.white(`🐳 Versão: ${backupCapability.dockerStatus.version}`));
   
   return { success: true };
 };

package/src/commands/backup/steps/01-database.js

@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Criando backup completo via pg_dumpall...'));
+    console.log(chalk.white('   - Criando backup completo via pg_dumpall...'));
     
     // Extrair credenciais da databaseUrl
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
@@ -45,7 +45,7 @@ module.exports = async ({ databaseUrl, backupDir }) => {
       `-f /host/${fileName}`
     ].join(' ');
     
-    console.log(chalk.gray('   - Executando pg_dumpall via Docker...'));
+    console.log(chalk.white('   - Executando pg_dumpall via Docker...'));
     execSync(dockerCmd, { stdio: 'pipe' });
     
     // Compactar igual ao Supabase Dashboard

package/src/commands/backup/steps/02-database-separated.js

@@ -8,14 +8,14 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.gray('   - Criando backups SQL separados via Supabase CLI...'));
+    console.log(chalk.white('   - Criando backups SQL separados via Supabase CLI...'));
     
     const dbUrl = databaseUrl;
     const files = [];
     let totalSizeKB = 0;
     
     // 1. Backup do Schema
-    console.log(chalk.gray('   - Exportando schema...'));
+    console.log(chalk.white('   - Exportando schema...'));
     const schemaFile = path.join(backupDir, 'schema.sql');
     
     try {
@@ -33,7 +33,7 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     }
     
     // 2. Backup dos Dados
-    console.log(chalk.gray('   - Exportando dados...'));
+    console.log(chalk.white('   - Exportando dados...'));
     const dataFile = path.join(backupDir, 'data.sql');
     
     try {
@@ -51,7 +51,7 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     }
     
     // 3. Backup dos Roles
-    console.log(chalk.gray('   - Exportando roles...'));
+    console.log(chalk.white('   - Exportando roles...'));
     const rolesFile = path.join(backupDir, 'roles.sql');
     
     try {

package/src/commands/backup/steps/03-database-settings.js

@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, projectId, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Capturando Database Extensions and Settings...'));
+    console.log(chalk.white('   - Capturando Database Extensions and Settings...'));
     
     // Extrair credenciais da databaseUrl
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
@@ -125,7 +125,7 @@ AND EXISTS (
       '-A'  // Unaligned output
     ].join(' ');
     
-    console.log(chalk.gray('   - Executando queries de configurações via Docker...'));
+    console.log(chalk.white('   - Executando queries de configurações via Docker...'));
     const output = execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
     
     // Processar output e criar JSON estruturado

package/src/commands/backup/steps/04-auth-settings.js

@@ -7,7 +7,7 @@ const { writeJson } = require('../../../utils/fsx');
  */
 module.exports = async ({ projectId, accessToken, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Exportando configurações de Auth via Management API...'));
+    console.log(chalk.white('   - Exportando configurações de Auth via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const authResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/config/auth`, {

package/src/commands/backup/steps/05-realtime-settings.js

@@ -8,7 +8,7 @@ const { captureRealtimeSettings } = require('../../../utils/realtime-settings');
  */
 module.exports = async ({ projectId, backupDir, options }) => {
   try {
-    console.log(chalk.gray('   - Capturando Realtime Settings interativamente...'));
+    console.log(chalk.white('   - Capturando Realtime Settings interativamente...'));
     
     const result = await captureRealtimeSettings(projectId, backupDir, options?.skipRealtime);
     

package/src/commands/backup/steps/06-storage.js

@@ -10,7 +10,7 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
 
-    console.log(chalk.gray('   - Listando buckets de Storage via Management API...'));
+    console.log(chalk.white('   - Listando buckets de Storage via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets`, {
@@ -28,20 +28,20 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
     const buckets = await storageResponse.json();
 
     if (!buckets || buckets.length === 0) {
-      console.log(chalk.gray('   - Nenhum bucket encontrado'));
+      console.log(chalk.white('   - Nenhum bucket encontrado'));
       await writeJson(path.join(storageDir, 'README.md'), {
         message: 'Nenhum bucket de Storage encontrado neste projeto'
       });
       return { success: true, buckets: [] };
     }
 
-    console.log(chalk.gray(`   - Encontrados ${buckets.length} buckets`));
+    console.log(chalk.white(`   - Encontrados ${buckets.length} buckets`));
 
     const processedBuckets = [];
 
     for (const bucket of buckets || []) {
       try {
-        console.log(chalk.gray(`   - Processando bucket: ${bucket.name}`));
+        console.log(chalk.white(`   - Processando bucket: ${bucket.name}`));
         
         // Listar objetos do bucket via Management API com Personal Access Token
         const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {

package/src/commands/backup/steps/07-custom-roles.js

@@ -11,7 +11,7 @@ const execAsync = promisify(exec);
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.gray('   - Exportando Custom Roles via Docker...'));
+    console.log(chalk.white('   - Exportando Custom Roles via Docker...'));
     
     const customRolesFile = path.join(backupDir, 'custom-roles.sql');
     

package/src/commands/backup/steps/08-edge-functions.js

@@ -45,18 +45,18 @@ module.exports = async (context) => {
     if (shouldCleanAfter) {
       // Limpar antes se o usuário escolheu limpar após (garante ambiente limpo)
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.gray('   - Pasta supabase/functions limpa antes do backup.'));
+      console.log(chalk.white('   - Pasta supabase/functions limpa antes do backup.'));
     } else {
       // Apenas garantir que o diretório existe
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
       if (existingFunctionsBefore.length > 0) {
-        console.log(chalk.gray(`   - Preservando ${existingFunctionsBefore.length} função(ões) existente(s) na pasta supabase/functions.`));
+        console.log(chalk.white(`   - Preservando ${existingFunctionsBefore.length} função(ões) existente(s) na pasta supabase/functions.`));
       } else {
-        console.log(chalk.gray('   - Pasta supabase/functions preparada (será preservada após backup).'));
+        console.log(chalk.white('   - Pasta supabase/functions preparada (será preservada após backup).'));
       }
     }
 
-    console.log(chalk.gray('   - Listando Edge Functions via Management API...'));
+    console.log(chalk.white('   - Listando Edge Functions via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const functionsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/functions`, {
@@ -74,14 +74,14 @@ module.exports = async (context) => {
     const functions = await functionsResponse.json();
     
     if (!functions || functions.length === 0) {
-      console.log(chalk.gray('   - Nenhuma Edge Function encontrada'));
+      console.log(chalk.white('   - Nenhuma Edge Function encontrada'));
       await writeJson(path.join(functionsDir, 'README.md'), {
         message: 'Nenhuma Edge Function encontrada neste projeto'
       });
       return { success: true, reason: 'no_functions', functions: [] };
     }
 
-    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
+    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
     
     const downloadedFunctions = [];
     let successCount = 0;
@@ -91,7 +91,7 @@ module.exports = async (context) => {
     // Nota: O CLI ignora o cwd e sempre baixa para supabase/functions
     for (const func of functions) {
       try {
-        console.log(chalk.gray(`   - Baixando: ${func.name}...`));
+        console.log(chalk.white(`   - Baixando: ${func.name}...`));
         
         // Criar diretório da função NO BACKUP
         const functionTargetDir = path.join(functionsDir, func.name);
@@ -167,11 +167,11 @@ module.exports = async (context) => {
     // Nota: shouldCleanAfter já foi definido acima
     if (shouldCleanAfter) {
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.gray('   - supabase/functions limpo após o backup.'));
+      console.log(chalk.white('   - supabase/functions limpo após o backup.'));
     } else {
       // Preservar tudo: tanto as funções que já existiam quanto as que foram baixadas
       // As funções baixadas não foram removidas individualmente (linha acima foi ajustada)
-      console.log(chalk.gray('   - supabase/functions preservada conforme solicitado.'));
+      console.log(chalk.white('   - supabase/functions preservada conforme solicitado.'));
     }
     
     return { 

package/src/commands/backup/steps/09-supabase-temp.js

@@ -14,10 +14,10 @@ module.exports = async (context) => {
     
     const fileCount = await copyDirSafe(tempDir, backupTempDir);
     
-    console.log(chalk.gray(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
+    console.log(chalk.white(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
     
     if (fileCount === 0) {
-      console.log(chalk.gray('   - Nenhum arquivo encontrado em supabase/.temp'));
+      console.log(chalk.white('   - Nenhum arquivo encontrado em supabase/.temp'));
     } else {
       console.log(chalk.green(`   ✅ ${fileCount} arquivo(s) copiado(s)`));
     }
@@ -27,7 +27,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(tempDir);
-      console.log(chalk.gray('   - supabase/.temp apagado.'));
+      console.log(chalk.white('   - supabase/.temp apagado.'));
     }
     
     return {

package/src/commands/backup/steps/10-migrations.js

@@ -17,10 +17,10 @@ module.exports = async (context) => {
     // Limpar migrations local (opcional, mas recomendado para garantir servidor como fonte da verdade)
     const migrationsDir = path.join(process.cwd(), 'supabase', 'migrations');
     await cleanDir(migrationsDir);
-    console.log(chalk.gray('   - Limpando supabase/migrations...'));
+    console.log(chalk.white('   - Limpando supabase/migrations...'));
     
     // Baixar todas as migrations do servidor usando migration fetch
-    console.log(chalk.gray('   - Baixando todas as migrations do servidor usando migration fetch...'));
+    console.log(chalk.white('   - Baixando todas as migrations do servidor usando migration fetch...'));
     
     const env = {
       ...process.env,
@@ -43,12 +43,12 @@ module.exports = async (context) => {
     
     // Contar arquivos baixados
     const fileCount = await countFiles(migrationsDir);
-    console.log(chalk.gray(`   - Arquivos baixados: ${fileCount} migrations`));
+    console.log(chalk.white(`   - Arquivos baixados: ${fileCount} migrations`));
     
     // Copiar migrations para o backup
     const backupMigrationsDir = path.join(backupDir, 'migrations');
     const copiedCount = await copyDirSafe(migrationsDir, backupMigrationsDir);
-    console.log(chalk.gray(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
+    console.log(chalk.white(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
     
     if (copiedCount > 0) {
       console.log(chalk.green(`   ✅ ${copiedCount} migration(s) copiada(s)`));

package/src/commands/restore/index.js

@@ -23,6 +23,18 @@ module.exports = async (_options) => {
   showBetaBanner();
   
   try {
+    // Termo de uso e aviso de risco
+    console.log(chalk.yellow.bold('\n⚠️  TERMO DE USO E AVISO DE RISCO\n'));
+    console.log(chalk.white('Ao prosseguir, você reconhece e concorda que o smoonb é fornecido "NO ESTADO EM QUE SE ENCONTRA" ("AS IS") e "CONFORME DISPONIBILIDADE", sem garantias de qualquer natureza—expressas, implícitas ou legais—incluindo, sem limitação, garantias de comercialização, adequação a um fim específico e não violação, na máxima extensão permitida pela lei aplicável. Operações de backup e restauração envolvem riscos, os ambientes variam amplamente e não é possível prever ou validar todas as configurações dos usuários. Você é o único responsável por validar seu ambiente, manter cópias independentes e verificar os resultados antes de utilizá-los em produção. O smoonb é construído com repositórios públicos, auditáveis e software livre, para auxiliar pessoas a simplificar seus fluxos, sem com isso criar qualquer garantia, promessa de suporte ou compromisso de nível de serviço.\n'));
+    console.log(chalk.white('Limitação de responsabilidade (PT-BR) — Na máxima extensão permitida por lei, a Goalmoon, seus contribuidores e licenciadores não serão responsáveis por danos indiretos, incidentais, especiais, consequentes, exemplares ou punitivos (incluindo perda de dados, interrupção de negócios ou lucros cessantes) decorrentes do uso, incapacidade de uso, das operações de backup/restauração realizadas com, ou dos resultados gerados pelo smoonb. Em qualquer hipótese, a responsabilidade total por todas as reivindicações relacionadas ao smoonb não excederá o valor pago por você pelo smoonb nos 12 meses anteriores ao evento. Nada neste aviso exclui ou limita responsabilidades onde tais limites sejam proibidos por lei, incluindo (conforme aplicável) dolo ou culpa grave.\n'));
+    console.log(chalk.white('Observação para consumidores no Brasil (PT-BR) — Para consumidores brasileiros, este aviso não afasta direitos irrenunciáveis previstos no Código de Defesa do Consumidor (CDC); qualquer limitação aqui prevista só se aplica nos limites da lei e não impede a indenização obrigatória quando cabível.\n'));
+    
+    const termsAccepted = await confirm('Você aceita os Termos de Uso e o Aviso de Risco de Restauração?', true);
+    if (!termsAccepted) {
+      console.log(chalk.red('🚫 Operação cancelada pelo usuário.'));
+      process.exit(1);
+    }
+
     // Executar validação Docker ANTES de tudo
     await step00DockerValidation();
 

package/src/commands/restore/steps/03-database.js

@@ -13,8 +13,8 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
     
     // Verificar se é arquivo .backup.gz (compactado) ou .backup (descompactado)
     if (fileName.endsWith('.backup.gz')) {
-      console.log(chalk.gray('   - Arquivo .backup.gz detectado'));
-      console.log(chalk.gray('   - Extraindo arquivo .gz...'));
+      console.log(chalk.white('   - Arquivo .backup.gz detectado'));
+      console.log(chalk.white('   - Extraindo arquivo .gz...'));
       
       const unzipCmd = [
         'docker run --rm',
@@ -24,10 +24,10 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       
       execSync(unzipCmd, { stdio: 'pipe' });
       uncompressedFile = fileName.replace('.gz', '');
-      console.log(chalk.gray('   - Arquivo descompactado: ' + uncompressedFile));
+      console.log(chalk.white('   - Arquivo descompactado: ' + uncompressedFile));
     } else if (fileName.endsWith('.backup')) {
-      console.log(chalk.gray('   - Arquivo .backup detectado (já descompactado)'));
-      console.log(chalk.gray('   - Prosseguindo com restauração direta'));
+      console.log(chalk.white('   - Arquivo .backup detectado (já descompactado)'));
+      console.log(chalk.white('   - Prosseguindo com restauração direta'));
     } else {
       throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
     }

package/src/commands/restore/steps/04-edge-functions.js

@@ -32,7 +32,7 @@ module.exports = async ({ backupPath, targetProject }) => {
       return { success: false, functions_count: 0, success_count: 0 };
     }
     
-    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
+    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
     
     // COPIAR Edge Functions de backups/backup-XXX/edge-functions para supabase/functions
     const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
@@ -54,13 +54,13 @@ module.exports = async ({ backupPath, targetProject }) => {
       const backupFuncPath = path.join(edgeFunctionsDir, funcName);
       const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
       
-      console.log(chalk.gray(`   - Copiando ${funcName} para supabase/functions...`));
+      console.log(chalk.white(`   - Copiando ${funcName} para supabase/functions...`));
       
       // Copiar recursivamente
       await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
     }
     
-    console.log(chalk.gray(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
+    console.log(chalk.white(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
     
     // Linkar com o projeto destino
     try {
@@ -77,7 +77,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     // Deploy das Edge Functions
     let successCount = 0;
     for (const funcName of functions) {
-      console.log(chalk.gray(`   - Deployando ${funcName}...`));
+      console.log(chalk.white(`   - Deployando ${funcName}...`));
       
       try {
         execSync(`supabase functions deploy ${funcName}`, {

package/src/commands/restore/steps/05-auth-settings.js

@@ -25,11 +25,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     if (authSettings.settings?.auth_url_config) {
       Object.entries(authSettings.settings.auth_url_config).forEach(([key, value]) => {
-        console.log(chalk.gray(`   - ${key}: ${value}`));
+        console.log(chalk.white(`   - ${key}: ${value}`));
       });
     } else if (authSettings.auth_url_config) {
       Object.entries(authSettings.auth_url_config).forEach(([key, value]) => {
-        console.log(chalk.gray(`   - ${key}: ${value}`));
+        console.log(chalk.white(`   - ${key}: ${value}`));
       });
     }
     

package/src/commands/restore/steps/06-storage.js

@@ -26,23 +26,23 @@ module.exports = async ({ backupPath }) => {
     const buckets = manifest?.components?.storage?.buckets || [];
     
     if (buckets.length === 0) {
-      console.log(chalk.gray('   ℹ️  Nenhum bucket para restaurar'));
+      console.log(chalk.white('   ℹ️  Nenhum bucket para restaurar'));
       return { success: false, buckets_count: 0 };
     }
     
     console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup`));
     buckets.forEach(bucket => {
-      console.log(chalk.gray(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
+      console.log(chalk.white(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
     });
     
     const colabUrl = 'https://colab.research.google.com/github/PLyn/supabase-storage-migrate/blob/main/Supabase_Storage_migration.ipynb';
     
     console.log(chalk.yellow('\n   ⚠️  Migração de objetos de Storage requer processo manual'));
     console.log(chalk.cyan(`   ℹ️  Use o script do Google Colab: ${colabUrl}`));
-    console.log(chalk.gray('\n   📋 Instruções:'));
-    console.log(chalk.gray('   1. Execute o script no Google Colab'));
-    console.log(chalk.gray('   2. Configure as credenciais dos projetos (origem e destino)'));
-    console.log(chalk.gray('   3. Execute a migração'));
+    console.log(chalk.white('\n   📋 Instruções:'));
+    console.log(chalk.white('   1. Execute o script no Google Colab'));
+    console.log(chalk.white('   2. Configure as credenciais dos projetos (origem e destino)'));
+    console.log(chalk.white('   3. Execute a migração'));
     
     await inquirer.prompt([{
       type: 'input',

package/src/commands/restore/steps/07-database-settings.js

@@ -22,11 +22,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     const extensions = dbSettings.extensions || [];
     
     if (extensions.length > 0) {
-      console.log(chalk.gray(`   - Habilitando ${extensions.length} extension(s)...`));
+      console.log(chalk.white(`   - Habilitando ${extensions.length} extension(s)...`));
       
       for (const ext of extensions) {
         const extName = typeof ext === 'string' ? ext : ext.name;
-        console.log(chalk.gray(`     - ${extName}`));
+        console.log(chalk.white(`     - ${extName}`));
         
         const sqlCommand = `CREATE EXTENSION IF NOT EXISTS ${extName};`;
         

package/src/commands/restore/steps/08-realtime-settings.js

@@ -25,9 +25,9 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     if (realtimeSettings.realtime_settings?.settings) {
       Object.values(realtimeSettings.realtime_settings.settings).forEach((setting) => {
-        console.log(chalk.gray(`   - ${setting.label}: ${setting.value}`));
+        console.log(chalk.white(`   - ${setting.label}: ${setting.value}`));
         if (setting.description) {
-          console.log(chalk.gray(`     ${setting.description}`));
+          console.log(chalk.white(`     ${setting.description}`));
         }
       });
     }

package/src/index.js

@@ -6,6 +6,7 @@
  */
 
 const chalk = require('chalk');
+const path = require('path');
 const { showBetaBanner } = require('./utils/banner');
 
 // Exportar comandos
@@ -62,50 +63,24 @@ function showQuickHelp() {
 🚀 COMANDOS PRINCIPAIS:
 
 📊 Backup completo:
-   npx smoonb backup                    # Usa configuração do .smoonbrc
+   npx smoonb backup                    # Backup completo interativo usando Docker
 
 🔄 Restauração completa:
-   npx smoonb restore --backup-dir <dir>  # Restaura backup usando psql
-
-⚡ Edge Functions:
-   npx smoonb functions list
-   npx smoonb functions push
+   npx smoonb restore                    # Restauração interativa usando psql (Docker)
 
 🔍 Verificação pós-restore:
    npx smoonb check                     # Verifica integridade do projeto
 
-⚙️  Configuração:
-   npx smoonb config --init             # Criar arquivo de configuração
-   npx smoonb config --show             # Mostrar configuração atual
-
-📋 CONFIGURAÇÃO AUTOMÁTICA:
-   npx smoonb config --init       # Cria .smoonbrc com projectId, URLs, etc.
-   # Edite o arquivo com suas credenciais Supabase
-   npx smoonb backup              # Funciona automaticamente!
-
-📝 EXEMPLO DE CONFIGURAÇÃO (.smoonbrc):
-   {
-     "supabase": {
-       "projectId": "abc123def456",
-       "url": "https://abc123def456.supabase.co",
-       "serviceKey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkXVCJ9...",
-       "anonKey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkXVCJ9...",
-       "databaseUrl": "postgresql://postgres:[senha]@db.abc123def456.supabase.co:5432/postgres",
-       "accessToken": "sbp_1234567890abcdef1234567890abcdef"
-     }
-   }
+📋 CONFIGURAÇÃO:
+   Configure o arquivo .env.local na raiz do projeto com suas credenciais Supabase.
+   O smoonb irá mapear as variáveis interativamente na primeira execução.
 
 🔑 PERSONAL ACCESS TOKEN (OBRIGATÓRIO):
    Para Management API (Edge Functions, Auth Settings, Storage):
    1. Acesse: https://supabase.com/dashboard/account/tokens
    2. Clique em "Generate new token"
    3. Copie o token (formato: sbp_...)
-   4. Adicione ao .smoonbrc como "accessToken"
-
-🔧 COMO CONFIGURAR:
-   1. npx smoonb config --init
-   2. Edite .smoonbrc com suas credenciais
-   3. npx smoonb backup (funciona automaticamente!)
+   4. Adicione ao .env.local como SUPABASE_ACCESS_TOKEN
 `));
 }
 
@@ -195,7 +170,7 @@ function checkCurrentConfig() {
   
   if (config) {
     console.log(chalk.green('✅ Arquivo de configuração encontrado'));
-    console.log(chalk.gray(`   - Localização: ${require('os').homedir()}/.smoonbrc`));
+    console.log(chalk.gray(`   - Localização: ${path.join(process.cwd(), '.env.local')}`));
     
     if (config.supabase?.url) {
       console.log(chalk.gray(`   - Supabase URL: ${config.supabase.url}`));
@@ -210,7 +185,7 @@ function checkCurrentConfig() {
     }
   } else {
     console.log(chalk.yellow('⚠️  Arquivo de configuração não encontrado'));
-    console.log(chalk.gray('   - Use: smoonb config --init'));
+    console.log(chalk.gray('   - Configure o arquivo .env.local na raiz do projeto'));
   }
   
   if (hasCredentials) {

package/src/utils/banner.js

@@ -1,32 +1,28 @@
 const chalk = require('chalk');
 
 /**
- * Banner da versão experimental
+ * Banner principal do smoonb
  */
 function showBetaBanner() {
-  console.log(chalk.red.bold(`
-╔══════════════════════════════════════════════════════════════╗
-║                    🚀 smoonb                                ║
-║                                                              ║
-║              ⚠️  EXPERIMENTAL VERSION - NÃO TESTADA!        ║
-║                                                              ║
-║  🚨 AVISO: Este software NUNCA foi testado em produção!     ║
-║  ⚠️  USE POR SUA CONTA E RISCO - Pode causar perda de dados ║
-║  ❌ NÃO NOS RESPONSABILIZAMOS por qualquer perda de dados   ║
-║                                                              ║
-║  A primeira ferramenta CLI completa para backup e migração  ║
-║  de projetos Supabase. Resolve o problema de backup        ║
-║  incompleto das ferramentas existentes.                     ║
-║                                                              ║
-║  ✅ Database PostgreSQL + Edge Functions + Auth Settings     ║
-║  ✅ Storage Objects + Realtime Settings + Metadados          ║
-║                                                              ║
-║  🏢 Desenvolvido por: Goalmoon Tecnologia LTDA              ║
-║  🌐 Website: https://goalmoon.com                           ║
-║  📖 Documentação: https://github.com/almmello/smoonb       ║
-║  🐛 Issues: https://github.com/almmello/smoonb/issues      ║
-╚══════════════════════════════════════════════════════════════╝
-`));
+  console.log(chalk.cyan.bold('\n🚀 Supa Moonbase (smoonb)\n'));
+  console.log(chalk.white('A primeira ferramenta CLI completa para backup e migração de projetos Supabase.'));
+  console.log(chalk.white('Resolve o problema de backup incompleto das ferramentas existentes.\n'));
+  
+  console.log(chalk.cyan.bold('📦 Componentes de Backup:\n'));
+  console.log(chalk.white('  ✅ Database PostgreSQL (pg_dumpall + SQL separados)'));
+  console.log(chalk.white('  ✅ Database Extensions and Settings'));
+  console.log(chalk.white('  ✅ Custom Roles'));
+  console.log(chalk.white('  ✅ Edge Functions'));
+  console.log(chalk.white('  ✅ Auth Settings'));
+  console.log(chalk.white('  ✅ Storage Buckets'));
+  console.log(chalk.white('  ✅ Realtime Settings'));
+  console.log(chalk.white('  ✅ Supabase .temp'));
+  console.log(chalk.white('  ✅ Migrations\n'));
+  
+  console.log(chalk.white('🏢 Desenvolvido por: Goalmoon Tecnologia LTDA'));
+  console.log(chalk.cyan('🌐 Website: https://smoonb.com'));
+  console.log(chalk.gray('📖 Documentação: https://github.com/almmello/smoonb'));
+  console.log(chalk.gray('🐛 Issues: https://github.com/almmello/smoonb/issues\n'));
 }
 
 module.exports = { showBetaBanner };

package/src/utils/realtime-settings.js

@@ -35,7 +35,7 @@ async function captureRealtimeSettings(projectId, backupDir, skipInteractive = f
   console.log('\n🔧 Configurações de Realtime Settings');
   console.log('═'.repeat(50));
   console.log(`📱 Acesse: ${dashboardUrl}`);
-  console.log('📝 Anote os valores dos 4 parâmetros abaixo:\n');
+  console.log('📝 Anote os valores dos 7 parâmetros abaixo:\n');
   
   const settings = await captureSettingsInteractively(projectId, previousSettings);
   
@@ -126,38 +126,61 @@ async function captureSettingsInteractively(projectId, previousSettings) {
     
     // Valores padrão baseados na imagem ou configurações anteriores
     const defaults = previousSettings?.realtime_settings?.settings || {
+      enable_realtime_service: { value: true },
       allow_public_access: { value: true },
       database_connection_pool_size: { value: 2 },
       max_concurrent_clients: { value: 200 },
-      max_events_per_second: { value: 100 }
+      max_events_per_second: { value: 100 },
+      max_presence_events_per_second: { value: 100 },
+      max_payload_size_kb: { value: 100 }
     };
     
+    const enableRealtime = await askQuestion(
+      '1. Enable Realtime service (true/false):',
+      defaults.enable_realtime_service?.value ?? true
+    );
+    
     const allowPublicAccess = await askQuestion(
-      '1. Allow public access (true/false):',
+      '2. Allow public access (true/false):',
       defaults.allow_public_access.value
     );
     
     const poolSize = await askQuestion(
-      '2. Database connection pool size:',
+      '3. Database connection pool size:',
       defaults.database_connection_pool_size.value
     );
     
     const maxClients = await askQuestion(
-      '3. Max concurrent clients:',
+      '4. Max concurrent clients:',
       defaults.max_concurrent_clients.value
     );
     
     const maxEvents = await askQuestion(
-      '4. Max events per second:',
+      '5. Max events per second:',
       defaults.max_events_per_second.value
     );
     
+    const maxPresenceEvents = await askQuestion(
+      '6. Max presence events per second:',
+      defaults.max_presence_events_per_second?.value ?? 100
+    );
+    
+    const maxPayloadSize = await askQuestion(
+      '7. Max payload size in KB:',
+      defaults.max_payload_size_kb?.value ?? 100
+    );
+    
     const settings = {
       realtime_settings: {
         note: "Configurações de Realtime Settings capturadas interativamente",
         dashboard_url: `https://supabase.com/dashboard/project/${projectId}/realtime/settings`,
         captured_at: new Date().toISOString(),
         settings: {
+          enable_realtime_service: {
+            label: "Enable Realtime service",
+            description: "If disabled, no clients will be able to connect and new connections will be rejected",
+            value: enableRealtime === 'true' || enableRealtime === true
+          },
           allow_public_access: {
             label: "Allow public access",
             description: "If disabled, only private channels will be allowed",
@@ -177,17 +200,30 @@ async function captureSettingsInteractively(projectId, previousSettings) {
             label: "Max events per second",
             description: "Sets maximum number of events per second that can be sent to your Realtime service",
             value: parseInt(maxEvents)
+          },
+          max_presence_events_per_second: {
+            label: "Max presence events per second",
+            description: "Sets maximum number of presence events per second",
+            value: parseInt(maxPresenceEvents)
+          },
+          max_payload_size_kb: {
+            label: "Max payload size in KB",
+            description: "Sets maximum payload size in KB",
+            value: parseInt(maxPayloadSize)
           }
         },
         restore_instructions: {
           url: `https://supabase.com/dashboard/project/${projectId}/realtime/settings`,
           steps: [
             "1. Acesse a URL acima",
-            "2. Configure 'Allow public access' conforme o valor em settings.allow_public_access.value",
-            "3. Configure 'Database connection pool size' conforme o valor em settings.database_connection_pool_size.value",
-            "4. Configure 'Max concurrent clients' conforme o valor em settings.max_concurrent_clients.value", 
-            "5. Configure 'Max events per second' conforme o valor em settings.max_events_per_second.value",
-            "6. Clique em 'Save changes'"
+            "2. Configure 'Enable Realtime service' conforme o valor em settings.enable_realtime_service.value",
+            "3. Configure 'Allow public access' conforme o valor em settings.allow_public_access.value",
+            "4. Configure 'Database connection pool size' conforme o valor em settings.database_connection_pool_size.value",
+            "5. Configure 'Max concurrent clients' conforme o valor em settings.max_concurrent_clients.value", 
+            "6. Configure 'Max events per second' conforme o valor em settings.max_events_per_second.value",
+            "7. Configure 'Max presence events per second' conforme o valor em settings.max_presence_events_per_second.value",
+            "8. Configure 'Max payload size in KB' conforme o valor em settings.max_payload_size_kb.value",
+            "9. Clique em 'Save changes'"
           ]
         }
       }

package/src/utils/supabaseLink.js

@@ -28,7 +28,7 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
   const tempDir = path.join(process.cwd(), 'supabase', '.temp');
   
   // Remover supabase/.temp completamente
-  console.log(chalk.gray(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
+  console.log(chalk.white(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
   
   try {
     await fs.rm(tempDir, { recursive: true, force: true });
@@ -66,7 +66,7 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
       );
     }
     
-    console.log(chalk.gray(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
+    console.log(chalk.white(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
   } catch (error) {
     if (error.message.includes('Validação falhou')) {
       throw error;