smoonb 0.0.52 → 0.0.55

package/package.json

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

package/src/commands/backup/index.js

@@ -140,12 +140,20 @@ 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'}`));
+    if (flags.includeFunctions) {
+      console.log(chalk.gray(`      🗑️  Limpar após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
+    }
+    console.log(chalk.gray(`   ✅ 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.gray(`   ✅ 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.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(`   🗑️  Limpar supabase/functions após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   🗑️  Apagar supabase/.temp após backup: ${flags.cleanTemp ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   🗑️  Apagar supabase/migrations após backup: ${flags.cleanMigrations ? 'Sim' : 'Não'}`));
     console.log(chalk.gray(`   📁 Diretório de backup: ${finalBackupDir}\n`));
 
     const finalOk = await confirm('Deseja iniciar o backup com estas configurações?', true);
@@ -187,13 +195,21 @@ module.exports = async (options) => {
     console.log(chalk.blue(`📁 Diretório: ${finalBackupDir}`));
     console.log(chalk.gray(`🐳 Backup via Docker Desktop`));
 
+    // Contar etapas totais para numeração
+    // Etapas fixas: Database, Database Separado, Database Settings, Custom Roles (4)
+    // Etapas condicionais: Auth, Realtime, Storage, Functions, Temp, Migrations
+    let stepNumber = 0;
+    const totalSteps = 4 + (flags?.includeAuth ? 1 : 0) + (flags?.includeRealtime ? 1 : 0) + (flags?.includeStorage ? 1 : 0) + (flags?.includeFunctions ? 1 : 0) + (flags?.includeTemp ? 1 : 0) + (flags?.includeMigrations ? 1 : 0);
+
     // 1. Backup Database via pg_dumpall Docker
-    console.log(chalk.blue('\n📊 1/11 - Backup da Database PostgreSQL via pg_dumpall Docker...'));
+    stepNumber++;
+    console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - Backup da Database PostgreSQL via pg_dumpall Docker...`));
     const databaseResult = await step01Database(context);
     manifest.components.database = databaseResult;
 
     // 2. Backup Database Separado
-    console.log(chalk.blue('\n📊 2/11 - Backup da Database PostgreSQL (arquivos SQL separados)...'));
+    stepNumber++;
+    console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - Backup da Database PostgreSQL (arquivos SQL separados)...`));
     const dbSeparatedResult = await step02DatabaseSeparated(context);
     manifest.components.database_separated = {
       success: dbSeparatedResult.success,
@@ -203,76 +219,79 @@ module.exports = async (options) => {
     };
 
     // 3. Backup Database Settings
-    console.log(chalk.blue('\n🔧 3/11 - Backup das Database Extensions and Settings via SQL...'));
+    stepNumber++;
+    console.log(chalk.blue(`\n🔧 ${stepNumber}/${totalSteps} - Backup das Database Extensions and Settings via SQL...`));
     const databaseSettingsResult = await step03DatabaseSettings(context);
     manifest.components.database_settings = databaseSettingsResult;
 
     // 4. Backup Auth Settings
     if (flags?.includeAuth) {
-      console.log(chalk.blue('\n🔐 4/11 - Backup das Auth Settings via API...'));
+      stepNumber++;
+      console.log(chalk.blue(`\n🔐 ${stepNumber}/${totalSteps} - Backup das Auth Settings via API...`));
       const authResult = await step04AuthSettings(context);
       manifest.components.auth_settings = authResult;
     }
 
     // 5. Backup Realtime Settings
     if (flags?.includeRealtime) {
-      console.log(chalk.blue('\n🔄 5/11 - Backup das Realtime Settings via Captura Interativa...'));
+      stepNumber++;
+      console.log(chalk.blue(`\n🔄 ${stepNumber}/${totalSteps} - Backup das Realtime Settings via Captura Interativa...`));
       const realtimeResult = await step05RealtimeSettings(context);
       manifest.components.realtime = realtimeResult;
     }
 
     // 6. Backup Storage
     if (flags?.includeStorage) {
-      console.log(chalk.blue('\n📦 6/11 - Backup do Storage via API...'));
+      stepNumber++;
+      console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - Backup do Storage via API...`));
       const storageResult = await step06Storage(context);
       manifest.components.storage = storageResult;
     }
 
     // 7. Backup Custom Roles
-    console.log(chalk.blue('\n👥 7/11 - Backup dos Custom Roles via SQL...'));
+    stepNumber++;
+    console.log(chalk.blue(`\n👥 ${stepNumber}/${totalSteps} - Backup dos Custom Roles via SQL...`));
     const rolesResult = await step07CustomRoles(context);
     manifest.components.custom_roles = rolesResult;
 
     // 8. Backup Edge Functions
     if (flags?.includeFunctions) {
-      console.log(chalk.blue('\n⚡ 8/11 - Backup das Edge Functions via Docker...'));
+      stepNumber++;
+      console.log(chalk.blue(`\n⚡ ${stepNumber}/${totalSteps} - Backup das Edge Functions via Docker...`));
       const functionsResult = await step08EdgeFunctions(context);
       manifest.components.edge_functions = functionsResult;
     }
 
     // 9. Backup Supabase .temp
-    console.log(chalk.blue('\n📁 9/11 - Backup do Supabase .temp...'));
-    const supabaseTempResult = await step09SupabaseTemp(context);
-    manifest.components.supabase_temp = supabaseTempResult;
+    if (flags?.includeTemp) {
+      stepNumber++;
+      console.log(chalk.blue(`\n📁 ${stepNumber}/${totalSteps} - Backup do Supabase .temp...`));
+      const supabaseTempResult = await step09SupabaseTemp(context);
+      manifest.components.supabase_temp = supabaseTempResult;
+    }
 
     // 10. Backup Migrations
-    console.log(chalk.blue('\n📋 10/11 - Backup das Migrations...'));
-    const migrationsResult = await step10Migrations(context);
-    manifest.components.migrations = migrationsResult;
+    if (flags?.includeMigrations) {
+      stepNumber++;
+      console.log(chalk.blue(`\n📋 ${stepNumber}/${totalSteps} - Backup das Migrations...`));
+      const migrationsResult = await step10Migrations(context);
+      manifest.components.migrations = migrationsResult;
+    }
 
     // Salvar manifest
     await writeJson(path.join(finalBackupDir, 'backup-manifest.json'), manifest);
 
-    // Exibir resumo final
+    // Exibir resumo final (na ordem de captura)
     console.log(chalk.green('\n🎉 BACKUP COMPLETO FINALIZADO VIA DOCKER!'));
     console.log(chalk.blue(`📁 Localização: ${finalBackupDir}`));
     console.log(chalk.green(`📊 Database: ${databaseResult.fileName} (${databaseResult.size} KB) - Idêntico ao Dashboard`));
     console.log(chalk.green(`📊 Database SQL: ${dbSeparatedResult.files?.length || 0} arquivos separados (${dbSeparatedResult.totalSizeKB} KB) - Para troubleshooting`));
     console.log(chalk.green(`🔧 Database Settings: ${databaseSettingsResult.fileName} (${databaseSettingsResult.size} KB) - Extensions e Configurações`));
     
-    if (flags?.includeFunctions && manifest.components.edge_functions) {
-      const functionsResult = manifest.components.edge_functions;
-      console.log(chalk.green(`⚡ Edge Functions: ${functionsResult.success_count || 0}/${functionsResult.functions_count || 0} functions baixadas via Docker`));
-    }
     if (flags?.includeAuth && manifest.components.auth_settings) {
       const authResult = manifest.components.auth_settings;
       console.log(chalk.green(`🔐 Auth Settings: ${authResult.success ? 'Exportadas via API' : 'Falharam'}`));
     }
-    if (flags?.includeStorage && manifest.components.storage) {
-      const storageResult = manifest.components.storage;
-      console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API`));
-    }
-    console.log(chalk.green(`👥 Custom Roles: ${rolesResult.roles?.length || 0} roles exportados via SQL`));
     
     // Determinar mensagem correta baseada no método usado
     if (flags?.includeRealtime && manifest.components.realtime) {
@@ -287,6 +306,28 @@ module.exports = async (options) => {
       }
       console.log(chalk.green(`🔄 Realtime: ${realtimeMessage}`));
     }
+    
+    if (flags?.includeStorage && manifest.components.storage) {
+      const storageResult = manifest.components.storage;
+      console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API`));
+    }
+    
+    console.log(chalk.green(`👥 Custom Roles: ${rolesResult.roles?.length || 0} roles exportados via SQL`));
+    
+    if (flags?.includeFunctions && manifest.components.edge_functions) {
+      const functionsResult = manifest.components.edge_functions;
+      console.log(chalk.green(`⚡ Edge Functions: ${functionsResult.success_count || 0}/${functionsResult.functions_count || 0} functions baixadas via Docker`));
+    }
+    
+    if (flags?.includeTemp && manifest.components.supabase_temp) {
+      const tempResult = manifest.components.supabase_temp;
+      console.log(chalk.green(`📁 Supabase .temp: ${tempResult.file_count || 0} arquivo(s) copiado(s)`));
+    }
+    
+    if (flags?.includeMigrations && manifest.components.migrations) {
+      const migrationsResult = manifest.components.migrations;
+      console.log(chalk.green(`📋 Migrations: ${migrationsResult.file_count || 0} migration(s) copiada(s)`));
+    }
 
     // report.json
     await writeJson(path.join(finalBackupDir, 'report.json'), {
@@ -302,7 +343,9 @@ module.exports = async (options) => {
         includeFunctions: !!flags?.includeFunctions,
         includeStorage: !!flags?.includeStorage,
         includeAuth: !!flags?.includeAuth,
-        includeRealtime: !!flags?.includeRealtime
+        includeRealtime: !!flags?.includeRealtime,
+        includeTemp: !!flags?.includeTemp,
+        includeMigrations: !!flags?.includeMigrations
       }
     });
 

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

@@ -8,7 +8,7 @@ const { showDockerMessagesAndExit } = require('../utils');
  */
 module.exports = async () => {
   console.log(chalk.blue('\n🐳 Validação Docker...'));
-  console.log(chalk.gray('🔍 Verificando dependências Docker...'));
+  console.log(chalk.cyan('🔍 Verificando dependências Docker...'));
   
   const backupCapability = await canPerformCompleteBackup();
 

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

@@ -18,10 +18,43 @@ module.exports = async (context) => {
     const dbPassword = extractPasswordFromDbUrl(databaseUrl);
     await ensureCleanLink(projectId, accessToken, dbPassword);
 
-    // Limpar pasta supabase/functions antes do backup
+    // Preparar diretório supabase/functions (criar se não existir, mas não limpar ainda)
     const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
-    await cleanDir(supabaseFunctionsDir);
-    console.log(chalk.gray('   - Pasta supabase/functions limpa.'));
+    
+    // Verificar flag de limpeza antes do backup
+    const shouldCleanAfter = context?.cleanupFlags?.cleanFunctions || false;
+    
+    // Registrar funções que já existiam ANTES do processo (para preservar se necessário)
+    let existingFunctionsBefore = [];
+    try {
+      const existingItems = await fs.readdir(supabaseFunctionsDir);
+      for (const item of existingItems) {
+        const itemPath = path.join(supabaseFunctionsDir, item);
+        const stats = await fs.stat(itemPath);
+        if (stats.isDirectory()) {
+          existingFunctionsBefore.push(item);
+        }
+      }
+    } catch {
+      // Diretório não existe, tudo bem
+      existingFunctionsBefore = [];
+    }
+    
+    // Se o usuário escolheu limpar APÓS, podemos limpar ANTES também para garantir ambiente limpo
+    // Mas se escolheu NÃO limpar, preservamos o que já existe
+    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.'));
+    } 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.`));
+      } else {
+        console.log(chalk.gray('   - Pasta supabase/functions preparada (será preservada após backup).'));
+      }
+    }
 
     console.log(chalk.gray('   - Listando Edge Functions via Management API...'));
     
@@ -99,12 +132,16 @@ module.exports = async (context) => {
           console.log(chalk.yellow(`     ⚠️ Nenhum arquivo encontrado em ${tempDownloadDir}`));
         }
         
-        // LIMPAR supabase/functions após copiar
-        try {
-          await fs.rm(tempDownloadDir, { recursive: true, force: true });
-        } catch {
-          // Ignorar erro de limpeza
+        // Limpar função baixada temporariamente APENAS se o usuário escolheu limpar após
+        // Se não escolheu, preservar (pode ser que já existisse antes)
+        if (shouldCleanAfter) {
+          try {
+            await fs.rm(tempDownloadDir, { recursive: true, force: true });
+          } catch {
+            // Ignorar erro de limpeza
+          }
         }
+        // Se shouldCleanAfter = false, manter a função baixada (e qualquer função que já existia)
         
         console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
         successCount++;
@@ -126,12 +163,15 @@ module.exports = async (context) => {
     console.log(chalk.green(`   ✅ Sucessos: ${successCount}`));
     console.log(chalk.green(`   ❌ Erros: ${errorCount}`));
     
-    // Usar flag de limpeza do contexto (já foi perguntado no início)
-    const shouldClean = context?.cleanupFlags?.cleanFunctions || false;
-    
-    if (shouldClean) {
+    // Limpar pasta supabase/functions APÓS o backup apenas se o usuário escolheu
+    // Nota: shouldCleanAfter já foi definido acima
+    if (shouldCleanAfter) {
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.gray('   - supabase/functions limpo.'));
+      console.log(chalk.gray('   - 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.'));
     }
     
     return { 

package/src/commands/restore/index.js

@@ -107,14 +107,14 @@ module.exports = async (_options) => {
     
     // 4. Mostrar resumo detalhado
     console.log(chalk.cyan('\n📋 RESUMO DA RESTAURAÇÃO:\n'));
-    console.log(chalk.gray(`   📁 Backup selecionado: ${path.basename(selectedBackup.path)}`));
-    console.log(chalk.gray(`   🎯 Projeto destino: ${targetProject.targetProjectId || '(não configurado)'}`));
-    console.log(chalk.gray(`   📊 Database: ${components.database ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   ⚡ Edge Functions: ${components.edgeFunctions ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   🔐 Auth Settings: ${components.authSettings ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   📦 Storage: ${components.storage ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   🔧 Database Settings: ${components.databaseSettings ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   🔄 Realtime Settings: ${components.realtimeSettings ? 'Sim' : 'Não'}\n`));
+    console.log(chalk.white(`   📁 Backup selecionado: ${path.basename(selectedBackup.path)}`));
+    console.log(chalk.white(`   🎯 Projeto destino: ${targetProject.targetProjectId || '(não configurado)'}`));
+    console.log(chalk.white(`   📊 Database: ${components.database ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ⚡ Edge Functions: ${components.edgeFunctions ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   🔐 Auth Settings: ${components.authSettings ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   📦 Storage: ${components.storage ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   🔧 Database Settings: ${components.databaseSettings ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   🔄 Realtime Settings: ${components.realtimeSettings ? 'Sim' : 'Não'}\n`));
     
     // Mostrar resumo técnico adicional
     showRestoreSummary(selectedBackup, components, targetProject);
@@ -129,51 +129,81 @@ module.exports = async (_options) => {
     // 6. Executar restauração
     console.log(chalk.blue('\n🚀 Iniciando restauração...'));
     
+    // Contar etapas totais para numeração dinâmica
+    let stepNumber = 0;
+    const totalSteps = (components.database ? 1 : 0) + 
+                      (components.edgeFunctions ? 1 : 0) + 
+                      (components.authSettings ? 1 : 0) + 
+                      (components.storage ? 1 : 0) + 
+                      (components.databaseSettings ? 1 : 0) + 
+                      (components.realtimeSettings ? 1 : 0);
+    
+    // Armazenar resultados para o resumo final
+    const restoreResults = {};
+    
     // 6.1 Database (se selecionado)
     if (components.database) {
+      stepNumber++;
+      console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - Restaurando Database...`));
       await step03Database({
         backupFilePath: path.join(selectedBackup.path, selectedBackup.backupFile),
         targetDatabaseUrl: targetProject.targetDatabaseUrl
       });
+      restoreResults.database = { success: true };
     }
     
     // 6.2 Edge Functions (se selecionado)
     if (components.edgeFunctions) {
-      await step04EdgeFunctions({
+      stepNumber++;
+      console.log(chalk.blue(`\n⚡ ${stepNumber}/${totalSteps} - Restaurando Edge Functions...`));
+      const edgeFunctionsResult = await step04EdgeFunctions({
         backupPath: selectedBackup.path,
         targetProject
       });
+      restoreResults.edgeFunctions = edgeFunctionsResult || { success: true };
     }
     
     // 6.3 Auth Settings (se selecionado)
     if (components.authSettings) {
+      stepNumber++;
+      console.log(chalk.blue(`\n🔐 ${stepNumber}/${totalSteps} - Restaurando Auth Settings...`));
       await step05AuthSettings({
         backupPath: selectedBackup.path,
         targetProject
       });
+      restoreResults.authSettings = { success: true };
     }
     
     // 6.4 Storage Buckets (se selecionado)
     if (components.storage) {
-      await step06Storage({
+      stepNumber++;
+      console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - Restaurando Storage Buckets...`));
+      const storageResult = await step06Storage({
         backupPath: selectedBackup.path
       });
+      restoreResults.storage = storageResult || { success: true };
     }
     
     // 6.5 Database Settings (se selecionado)
     if (components.databaseSettings) {
+      stepNumber++;
+      console.log(chalk.blue(`\n🔧 ${stepNumber}/${totalSteps} - Restaurando Database Settings...`));
       await step07DatabaseSettings({
         backupPath: selectedBackup.path,
         targetProject
       });
+      restoreResults.databaseSettings = { success: true };
     }
     
     // 6.6 Realtime Settings (se selecionado)
     if (components.realtimeSettings) {
+      stepNumber++;
+      console.log(chalk.blue(`\n🔄 ${stepNumber}/${totalSteps} - Restaurando Realtime Settings...`));
       await step08RealtimeSettings({
         backupPath: selectedBackup.path,
         targetProject
       });
+      restoreResults.realtimeSettings = { success: true };
     }
     
     // report.json de restauração
@@ -186,6 +216,7 @@ module.exports = async (_options) => {
         env_map: path.join(processDir, 'env', 'env-map.json')
       },
       components: components,
+      results: restoreResults,
       notes: [
         'supabase/functions limpo antes e depois do deploy (se Edge Functions selecionado)'
       ]
@@ -196,7 +227,36 @@ module.exports = async (_options) => {
       // silencioso
     }
 
-    console.log(chalk.green('\n🎉 Restauração completa finalizada!'));
+    // Exibir resumo final
+    console.log(chalk.green('\n🎉 RESTAURAÇÃO COMPLETA FINALIZADA!'));
+    console.log(chalk.blue(`🎯 Projeto destino: ${targetProject.targetProjectId || '(não configurado)'}`));
+    
+    if (restoreResults.database) {
+      console.log(chalk.green(`📊 Database: Restaurada com sucesso via Docker`));
+    }
+    
+    if (restoreResults.edgeFunctions) {
+      const funcCount = restoreResults.edgeFunctions.functions_count || 0;
+      const successCount = restoreResults.edgeFunctions.success_count || 0;
+      console.log(chalk.green(`⚡ Edge Functions: ${successCount}/${funcCount} functions restauradas`));
+    }
+    
+    if (restoreResults.authSettings) {
+      console.log(chalk.green(`🔐 Auth Settings: Configurações exibidas para configuração manual`));
+    }
+    
+    if (restoreResults.storage) {
+      const bucketCount = restoreResults.storage.buckets_count || 0;
+      console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) encontrado(s) - migração manual necessária`));
+    }
+    
+    if (restoreResults.databaseSettings) {
+      console.log(chalk.green(`🔧 Database Settings: Extensões e configurações restauradas via SQL`));
+    }
+    
+    if (restoreResults.realtimeSettings) {
+      console.log(chalk.green(`🔄 Realtime Settings: Configurações exibidas para configuração manual`));
+    }
     
   } catch (error) {
     console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));

package/src/commands/restore/steps/01-components-selection.js

@@ -15,8 +15,8 @@ module.exports = async (backupPath) => {
   let restoreEdgeFunctions = false;
   if (fs.existsSync(edgeFunctionsDir) && fs.readdirSync(edgeFunctionsDir).length > 0) {
     console.log(chalk.cyan('\n⚡ Edge Functions:'));
-    console.log(chalk.gray('   As Edge Functions serão copiadas para supabase/functions e implantadas no projeto destino.'));
-    console.log(chalk.gray('   A pasta supabase/functions será limpa antes do processo.\n'));
+    console.log(chalk.white('   As Edge Functions serão copiadas para supabase/functions e implantadas no projeto destino.'));
+    console.log(chalk.white('   A pasta supabase/functions será limpa antes do processo.\n'));
     restoreEdgeFunctions = await confirm('Deseja restaurar Edge Functions', true);
   }
   
@@ -24,8 +24,8 @@ module.exports = async (backupPath) => {
   let restoreAuthSettings = false;
   if (fs.existsSync(path.join(backupPath, 'auth-settings.json'))) {
     console.log(chalk.cyan('\n🔐 Auth Settings:'));
-    console.log(chalk.gray('   As configurações de Auth serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.gray('   Algumas configurações não podem ser aplicadas automaticamente por questões de segurança.\n'));
+    console.log(chalk.white('   As configurações de Auth serão exibidas para configuração manual no Dashboard.'));
+    console.log(chalk.white('   Algumas configurações não podem ser aplicadas automaticamente por questões de segurança.\n'));
     restoreAuthSettings = await confirm('Deseja ver as configurações de Auth Settings', true);
   }
   
@@ -34,8 +34,8 @@ module.exports = async (backupPath) => {
   let restoreStorage = false;
   if (fs.existsSync(storageDir) && fs.readdirSync(storageDir).length > 0) {
     console.log(chalk.cyan('\n📦 Storage:'));
-    console.log(chalk.gray('   As informações dos buckets de Storage serão exibidas para migração manual.'));
-    console.log(chalk.gray('   Os arquivos precisam ser migrados manualmente usando as ferramentas do Supabase.\n'));
+    console.log(chalk.white('   As informações dos buckets de Storage serão exibidas para migração manual.'));
+    console.log(chalk.white('   Os arquivos precisam ser migrados manualmente usando as ferramentas do Supabase.\n'));
     restoreStorage = await confirm('Deseja ver informações de Storage Buckets', true);
   }
   
@@ -45,8 +45,8 @@ module.exports = async (backupPath) => {
   let restoreDatabaseSettings = false;
   if (dbSettingsFiles.length > 0) {
     console.log(chalk.cyan('\n🔧 Database Extensions and Settings:'));
-    console.log(chalk.gray('   As extensões e configurações do banco de dados serão restauradas via SQL.'));
-    console.log(chalk.gray('   Isso inclui extensões PostgreSQL e configurações específicas do projeto.\n'));
+    console.log(chalk.white('   As extensões e configurações do banco de dados serão restauradas via SQL.'));
+    console.log(chalk.white('   Isso inclui extensões PostgreSQL e configurações específicas do projeto.\n'));
     restoreDatabaseSettings = await confirm('Deseja restaurar Database Extensions and Settings', true);
   }
   
@@ -54,8 +54,8 @@ module.exports = async (backupPath) => {
   let restoreRealtimeSettings = false;
   if (fs.existsSync(path.join(backupPath, 'realtime-settings.json'))) {
     console.log(chalk.cyan('\n🔄 Realtime Settings:'));
-    console.log(chalk.gray('   As configurações de Realtime serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.gray('   Algumas configurações precisam ser aplicadas manualmente.\n'));
+    console.log(chalk.white('   As configurações de Realtime serão exibidas para configuração manual no Dashboard.'));
+    console.log(chalk.white('   Algumas configurações precisam ser aplicadas manualmente.\n'));
     restoreRealtimeSettings = await confirm('Deseja ver as configurações de Realtime Settings', true);
   }
   

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

@@ -6,8 +6,6 @@ const { execSync } = require('child_process');
  * Etapa 3: Restaurar Database via psql
  */
 module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
-  console.log(chalk.blue('📊 Restaurando Database...'));
-  
   try {
     const backupDirAbs = path.resolve(path.dirname(backupFilePath));
     const fileName = path.basename(backupFilePath);
@@ -51,8 +49,8 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       `-f /host/${uncompressedFile}`
     ].join(' ');
     
-    console.log(chalk.gray('   - Executando psql via Docker...'));
-    console.log(chalk.gray('   ℹ️ Seguindo documentação oficial Supabase'));
+    console.log(chalk.cyan('   - Executando psql via Docker...'));
+    console.log(chalk.cyan('   ℹ️ Seguindo documentação oficial Supabase'));
     console.log(chalk.yellow('   ⚠️ AVISO: Erros como "object already exists" são ESPERADOS'));
     console.log(chalk.yellow('   ⚠️ Isto acontece porque o backup contém CREATE para todos os schemas'));
     console.log(chalk.yellow('   ⚠️ Supabase já tem auth e storage criados, então esses erros são normais'));

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

@@ -8,14 +8,12 @@ const { copyDirectoryRecursive } = require('../utils');
  * Etapa 4: Restaurar Edge Functions via supabase functions deploy
  */
 module.exports = async ({ backupPath, targetProject }) => {
-  console.log(chalk.blue('\n⚡ Restaurando Edge Functions...'));
-  
   try {
     const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
     
     if (!await fs.access(edgeFunctionsDir).then(() => true).catch(() => false)) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
-      return;
+      return { success: false, functions_count: 0, success_count: 0 };
     }
     
     const items = await fs.readdir(edgeFunctionsDir);
@@ -31,7 +29,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     if (functions.length === 0) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
-      return;
+      return { success: false, functions_count: 0, success_count: 0 };
     }
     
     console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
@@ -42,8 +40,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     // Criar diretório supabase/functions se não existir
     await fs.mkdir(supabaseFunctionsDir, { recursive: true });
     
-    // Limpar supabase/functions antes de copiar
-    console.log(chalk.gray('   - Limpando supabase/functions...'));
+    // Limpar supabase/functions antes de copiar (necessário para garantir ambiente limpo)
+    console.log(chalk.cyan('   - Limpando supabase/functions antes de copiar...'));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
@@ -77,6 +75,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     }
     
     // Deploy das Edge Functions
+    let successCount = 0;
     for (const funcName of functions) {
       console.log(chalk.gray(`   - Deployando ${funcName}...`));
       
@@ -90,13 +89,14 @@ module.exports = async ({ backupPath, targetProject }) => {
         });
         
         console.log(chalk.green(`   ✅ ${funcName} deployada com sucesso!`));
+        successCount++;
       } catch (deployError) {
         console.log(chalk.yellow(`   ⚠️  ${funcName} - deploy falhou: ${deployError.message}`));
       }
     }
     
-    // Limpar supabase/functions após deploy
-    console.log(chalk.gray('   - Limpando supabase/functions após deploy...'));
+    // Limpar supabase/functions após deploy (arquivos temporários não são mais necessários)
+    console.log(chalk.cyan('   - Limpando supabase/functions após deploy...'));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
     } catch {
@@ -105,8 +105,15 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     console.log(chalk.green('   ✅ Edge Functions restauradas com sucesso!'));
     
+    return {
+      success: true,
+      functions_count: functions.length,
+      success_count: successCount
+    };
+    
   } catch (error) {
     console.error(chalk.red(`   ❌ Erro ao restaurar Edge Functions: ${error.message}`));
+    throw error;
   }
 };
 

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

@@ -7,7 +7,6 @@ const inquirer = require('inquirer');
  * Etapa 5: Restaurar Auth Settings (interativo - exibir URL e valores)
  */
 module.exports = async ({ backupPath, targetProject }) => {
-  console.log(chalk.blue('\n🔐 Restaurando Auth Settings...'));
   
   try {
     const authSettingsPath = path.join(backupPath, 'auth-settings.json');

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

@@ -7,14 +7,13 @@ const inquirer = require('inquirer');
  * Etapa 6: Restaurar Storage Buckets (interativo - exibir informações)
  */
 module.exports = async ({ backupPath }) => {
-  console.log(chalk.blue('\n📦 Restaurando Storage Buckets...'));
   
   try {
     const storageDir = path.join(backupPath, 'storage');
     
     if (!fs.existsSync(storageDir)) {
       console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
-      return;
+      return { success: false, buckets_count: 0 };
     }
     
     const manifestPath = path.join(backupPath, 'backup-manifest.json');
@@ -28,7 +27,7 @@ module.exports = async ({ backupPath }) => {
     
     if (buckets.length === 0) {
       console.log(chalk.gray('   ℹ️  Nenhum bucket para restaurar'));
-      return;
+      return { success: false, buckets_count: 0 };
     }
     
     console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup`));
@@ -51,8 +50,14 @@ module.exports = async ({ backupPath }) => {
       message: 'Pressione Enter para continuar'
     }]);
     
+    return {
+      success: true,
+      buckets_count: buckets.length
+    };
+    
   } catch (error) {
     console.error(chalk.red(`   ❌ Erro ao processar Storage: ${error.message}`));
+    throw error;
   }
 };
 

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

@@ -7,15 +7,13 @@ const { execSync } = require('child_process');
  * Etapa 7: Restaurar Database Settings (via SQL)
  */
 module.exports = async ({ backupPath, targetProject }) => {
-  console.log(chalk.blue('\n🔧 Restaurando Database Settings...'));
-  
   try {
     const files = fs.readdirSync(backupPath);
     const dbSettingsFile = files.find(f => f.startsWith('database-settings-') && f.endsWith('.json'));
     
     if (!dbSettingsFile) {
       console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Database encontrada no backup'));
-      return;
+      return { success: false };
     }
     
     const dbSettingsData = JSON.parse(fs.readFileSync(path.join(backupPath, dbSettingsFile), 'utf8'));
@@ -58,8 +56,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     console.log(chalk.green('   ✅ Database Settings restaurados com sucesso!'));
     
+    return { success: true, extensions_count: extensions.length };
+    
   } catch (error) {
     console.error(chalk.red(`   ❌ Erro ao restaurar Database Settings: ${error.message}`));
+    throw error;
   }
 };
 

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

@@ -7,7 +7,6 @@ const inquirer = require('inquirer');
  * Etapa 8: Restaurar Realtime Settings (interativo - exibir URL e valores)
  */
 module.exports = async ({ backupPath, targetProject }) => {
-  console.log(chalk.blue('\n🔄 Restaurando Realtime Settings...'));
   
   try {
     const realtimeSettingsPath = path.join(backupPath, 'realtime-settings.json');

package/src/interactive/envMapper.js

@@ -84,36 +84,57 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
 async function askComponentsFlags() {
   // Explicação sobre Edge Functions
   console.log(chalk.cyan('\n⚡ Edge Functions:'));
-  console.log(chalk.gray('   Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link'));
-  console.log(chalk.gray('   entre a ferramenta e o projeto, e baixar novamente as funções do servidor.'));
-  console.log(chalk.gray('   Você terá a opção de manter ou apagar as funções na pasta após o backup.\n'));
+  console.log(chalk.white('   Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link'));
+  console.log(chalk.white('   entre a ferramenta e o projeto, e baixar novamente as funções do servidor.'));
+  console.log(chalk.white('   Você terá a opção de manter ou apagar as funções na pasta após o backup.\n'));
 
   const includeFunctions = await confirm('Deseja incluir Edge Functions', true);
+  
+  // Pergunta de limpeza de functions imediatamente após
+  let cleanFunctions = false;
+  if (includeFunctions) {
+    cleanFunctions = await confirm('Deseja limpar supabase/functions após o backup', false);
+  }
 
   // Explicação sobre .temp
   console.log(chalk.cyan('\n📁 Supabase .temp:'));
-  console.log(chalk.gray('   Vamos copiar os arquivos existentes (se existirem) na pasta supabase/.temp.'));
-  console.log(chalk.gray('   Você terá a opção de manter ou apagar os arquivos nesta pasta após o backup.\n'));
+  console.log(chalk.white('   Vamos copiar os arquivos existentes (se existirem) na pasta supabase/.temp.'));
+  console.log(chalk.white('   Você terá a opção de manter ou apagar os arquivos nesta pasta após o backup.\n'));
+
+  const includeTemp = await confirm('Deseja incluir Supabase .temp', true);
+  
+  // Pergunta de limpeza de .temp imediatamente após
+  let cleanTemp = false;
+  if (includeTemp) {
+    cleanTemp = await confirm('Deseja apagar supabase/.temp após o backup', false);
+  }
 
   // Explicação sobre Migrations
   console.log(chalk.cyan('\n📋 Migrations:'));
-  console.log(chalk.gray('   Vamos apagar as migrations existentes (se existirem) na pasta supabase/migrations,'));
-  console.log(chalk.gray('   fazer um reset no link entre a ferramenta e o projeto, e baixar novamente as migrations'));
-  console.log(chalk.gray('   do servidor. Você terá a opção de manter ou apagar as migrations na pasta após o backup.\n'));
+  console.log(chalk.white('   Vamos apagar as migrations existentes (se existirem) na pasta supabase/migrations,'));
+  console.log(chalk.white('   fazer um reset no link entre a ferramenta e o projeto, e baixar novamente as migrations'));
+  console.log(chalk.white('   do servidor. Você terá a opção de manter ou apagar as migrations na pasta após o backup.\n'));
+
+  const includeMigrations = await confirm('Deseja incluir Migrations', true);
+  
+  // Pergunta de limpeza de migrations imediatamente após
+  let cleanMigrations = false;
+  if (includeMigrations) {
+    cleanMigrations = await confirm('Deseja apagar supabase/migrations após o backup', false);
+  }
 
   // Continuar com outras perguntas
   const includeStorage = await confirm('Deseja incluir Storage', true);
   const includeAuth = await confirm('Deseja incluir Auth', true);
   const includeRealtime = await confirm('Deseja incluir Realtime', true);
-  const cleanFunctions = await confirm('Deseja limpar supabase/functions após o backup', false);
-  const cleanTemp = await confirm('Deseja apagar supabase/.temp após o backup', false);
-  const cleanMigrations = await confirm('Deseja apagar supabase/migrations após o backup', false);
 
   return {
     includeFunctions,
     includeStorage,
     includeAuth,
     includeRealtime,
+    includeTemp,
+    includeMigrations,
     cleanFunctions,
     cleanTemp,
     cleanMigrations