smoonb 0.0.51 → 0.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.51",
+  "version": "0.0.54",
   "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,19 @@ 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
+    let stepNumber = 0;
+    const totalSteps = 7 + (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 +217,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 +304,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 +341,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/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

@@ -1,7 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
-const { confirm } = require('../../utils/prompt');
+const { confirm } = require('../../../utils/prompt');
 
 /**
  * Etapa 1: Perguntar quais componentes restaurar
@@ -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/02-confirmation.js

@@ -2,7 +2,7 @@
 // A confirmação agora é feita no index.js com resumo detalhado
 // Mantido para compatibilidade, mas pode ser removido no futuro
 
-const { confirm } = require('../../utils/prompt');
+const { confirm } = require('../../../utils/prompt');
 
 /**
  * Etapa 2: Confirmar execução (LEGACY - não usado mais)

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

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)`));
@@ -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,6 +89,7 @@ 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}`));
       }
@@ -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