smoonb 0.0.33 → 0.0.35

package/.smoonbrc

@@ -4,7 +4,8 @@
     "url": "https://dfgdfgdfgdfgdfgdfg.supabase.co",
     "serviceKey": "sdfsdfsdfsdfsdfgyjyuiuyjyujuyjyujuyjyujuy",
     "anonKey": "uyjyujyujyhmnbmbghjghjghghjghjghjghj",
-    "databaseUrl": "postgresql://postgres:ghjghjghjghjghjghjghj@db.sdfsdfsdfsdfsdfsdfsdfsdf.supabase.co:5432/postgres"
+    "databaseUrl": "postgresql://postgres:ghjghjghjghjghjghjghj@db.sdfsdfsdfsdfsdfsdfsdfsdf.supabase.co:5432/postgres",
+    "accessToken": "your-personal-access-token-here"
   },
   "backup": {
     "includeFunctions": true,
@@ -15,7 +16,14 @@
     "pgDumpPath": "C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe"
   },
   "restore": {
-    "cleanRestore": false,
-    "verifyAfterRestore": true
+    "verifyAfterRestore": true,
+    "targetProject": {
+      "targetProjectId": "target-project-id-here",
+      "targetUrl": "https://target-project.supabase.co",
+      "targetServiceKey": "target-service-key",
+      "targetAnonKey": "target-anon-key",
+      "targetDatabaseUrl": "postgresql://postgres:[password]@db.target-project.supabase.co:5432/postgres",
+      "targetAccessToken": "target-access-token"
+    }
   }
 }

package/.smoonbrc.example

@@ -15,7 +15,14 @@
     "pgDumpPath": "C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe"
   },
   "restore": {
-    "cleanRestore": false,
-    "verifyAfterRestore": true
+    "verifyAfterRestore": true,
+    "targetProject": {
+      "targetProjectId": "target-project-id-here",
+      "targetUrl": "https://target-project.supabase.co",
+      "targetServiceKey": "target-service-key",
+      "targetAnonKey": "target-anon-key",
+      "targetDatabaseUrl": "postgresql://postgres:[password]@db.target-project.supabase.co:5432/postgres",
+      "targetAccessToken": "target-access-token"
+    }
   }
 }

package/package.json

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

package/src/commands/backup.js

@@ -108,37 +108,47 @@ async function performFullBackup(config, options) {
   };
 
   // 1. Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
-  console.log(chalk.blue('\n📊 1/7 - Backup da Database PostgreSQL via pg_dumpall Docker...'));
+  console.log(chalk.blue('\n📊 1/8 - Backup da Database PostgreSQL via pg_dumpall Docker...'));
   const databaseResult = await backupDatabase(config.supabase.projectId, backupDir);
   manifest.components.database = databaseResult;
 
+  // 1.5. Backup Database Separado (SQL files para troubleshooting)
+  console.log(chalk.blue('\n📊 1.5/8 - Backup da Database PostgreSQL (arquivos SQL separados)...'));
+  const dbSeparatedResult = await backupDatabaseSeparated(config.supabase.projectId, backupDir);
+  manifest.components.database_separated = {
+    success: dbSeparatedResult.success,
+    method: 'supabase-cli',
+    files: dbSeparatedResult.files || [],
+    total_size_kb: dbSeparatedResult.totalSizeKB || '0.0'
+  };
+
   // 2. Backup Edge Functions via Docker
-  console.log(chalk.blue('\n⚡ 2/7 - Backup das Edge Functions via Docker...'));
+  console.log(chalk.blue('\n⚡ 2/8 - Backup das Edge Functions via Docker...'));
   const functionsResult = await backupEdgeFunctionsWithDocker(config.supabase.projectId, config.supabase.accessToken, backupDir);
   manifest.components.edge_functions = functionsResult;
 
   // 3. Backup Auth Settings via API
-  console.log(chalk.blue('\n🔐 3/7 - Backup das Auth Settings via API...'));
+  console.log(chalk.blue('\n🔐 3/8 - Backup das Auth Settings via API...'));
   const authResult = await backupAuthSettings(config.supabase.projectId, config.supabase.accessToken, backupDir);
   manifest.components.auth_settings = authResult;
 
   // 4. Backup Storage via API
-  console.log(chalk.blue('\n📦 4/7 - Backup do Storage via API...'));
+  console.log(chalk.blue('\n📦 4/8 - Backup do Storage via API...'));
   const storageResult = await backupStorage(config.supabase.projectId, config.supabase.accessToken, backupDir);
   manifest.components.storage = storageResult;
 
   // 5. Backup Custom Roles via SQL
-  console.log(chalk.blue('\n👥 5/7 - Backup dos Custom Roles via SQL...'));
+  console.log(chalk.blue('\n👥 5/8 - Backup dos Custom Roles via SQL...'));
   const rolesResult = await backupCustomRoles(config.supabase.databaseUrl, backupDir);
   manifest.components.custom_roles = rolesResult;
 
   // 6. Backup das Database Extensions and Settings via SQL
-  console.log(chalk.blue('\n🔧 6/7 - Backup das Database Extensions and Settings via SQL...'));
+  console.log(chalk.blue('\n🔧 6/8 - Backup das Database Extensions and Settings via SQL...'));
   const databaseSettingsResult = await backupDatabaseSettings(config.supabase.projectId, backupDir);
   manifest.components.database_settings = databaseSettingsResult;
 
   // 7. Backup Realtime Settings via Captura Interativa
-  console.log(chalk.blue('\n🔄 7/7 - Backup das Realtime Settings via Captura Interativa...'));
+  console.log(chalk.blue('\n🔄 7/8 - Backup das Realtime Settings via Captura Interativa...'));
   const realtimeResult = await backupRealtimeSettings(config.supabase.projectId, backupDir, options.skipRealtime);
   manifest.components.realtime = realtimeResult;
 
@@ -148,6 +158,7 @@ async function performFullBackup(config, options) {
   console.log(chalk.green('\n🎉 BACKUP COMPLETO FINALIZADO VIA DOCKER!'));
   console.log(chalk.blue(`📁 Localização: ${backupDir}`));
   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`));
   console.log(chalk.green(`⚡ Edge Functions: ${functionsResult.success_count || 0}/${functionsResult.functions_count || 0} functions baixadas via Docker`));
   console.log(chalk.green(`🔐 Auth Settings: ${authResult.success ? 'Exportadas via API' : 'Falharam'}`));
@@ -297,6 +308,75 @@ async function backupDatabase(projectId, backupDir) {
   }
 }
 
+// Backup da database usando arquivos SQL separados via Supabase CLI (para troubleshooting)
+async function backupDatabaseSeparated(projectId, backupDir) {
+  try {
+    console.log(chalk.gray('   - Criando backups SQL separados via Supabase CLI...'));
+    
+    const { execSync } = require('child_process');
+    const config = await readConfig();
+    
+    const dbUrl = config.supabase.databaseUrl;
+    const files = [];
+    let totalSizeKB = 0;
+    
+    // 1. Backup do Schema
+    console.log(chalk.gray('   - Exportando schema...'));
+    const schemaFile = path.join(backupDir, 'schema.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`, { stdio: 'pipe' });
+      const stats = await fs.stat(schemaFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'schema.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro no schema: ${error.message}`));
+    }
+    
+    // 2. Backup dos Dados
+    console.log(chalk.gray('   - Exportando dados...'));
+    const dataFile = path.join(backupDir, 'data.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`, { stdio: 'pipe' });
+      const stats = await fs.stat(dataFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'data.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro nos dados: ${error.message}`));
+    }
+    
+    // 3. Backup dos Roles
+    console.log(chalk.gray('   - Exportando roles...'));
+    const rolesFile = path.join(backupDir, 'roles.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`, { stdio: 'pipe' });
+      const stats = await fs.stat(rolesFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'roles.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro nos roles: ${error.message}`));
+    }
+    
+    return { 
+      success: files.length > 0, 
+      files, 
+      totalSizeKB: totalSizeKB.toFixed(1) 
+    };
+    
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro nos backups SQL separados: ${error.message}`));
+    return { success: false, files: [], totalSizeKB: '0.0' };
+  }
+}
+
 // Backup das Edge Functions via Docker
 async function backupEdgeFunctionsWithDocker(projectId, accessToken, backupDir) {
   try {

package/src/commands/restore.js

@@ -1,252 +1,390 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
-const inquirer = require('inquirer');
-const { ensureBin, runCommand } = require('../utils/cli');
-const { readConfig, validateFor } = require('../utils/config');
+const { readConfig, getSourceProject, getTargetProject } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
 
-// Exportar FUNÇÃO em vez de objeto Command
 module.exports = async (options) => {
   showBetaBanner();
   
   try {
-    // Verificar se psql está disponível
-    const psqlPath = await ensureBin('psql');
-    if (!psqlPath) {
-      console.error(chalk.red('❌ psql não encontrado'));
-      console.log(chalk.yellow('💡 Instale PostgreSQL:'));
-      console.log(chalk.yellow('  https://www.postgresql.org/download/'));
-      process.exit(1);
-    }
-
-    // Carregar configuração
     const config = await readConfig();
-    validateFor(config, 'restore');
-
-    // Resolver URL da database
-    const databaseUrl = options.dbUrl || config.supabase.databaseUrl;
-    if (!databaseUrl) {
-      console.error(chalk.red('❌ databaseUrl não configurada'));
-      console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc ou use --db-url'));
-      process.exit(1);
-    }
-
-    console.log(chalk.blue(`🔍 Procurando backups em: ${config.backup.outputDir || './backups'}`));
-
-    // Listar backups disponíveis
-    const backups = await listAvailableBackups(config.backup.outputDir || './backups');
+    const targetProject = getTargetProject(config);
     
-    if (backups.length === 0) {
-      console.error(chalk.red('❌ Nenhum backup encontrado'));
+    console.log(chalk.blue(`📁 Buscando backups em: ${config.backup.outputDir || './backups'}`));
+    
+    // 1. Listar backups válidos (.backup.gz)
+    const validBackups = await listValidBackups(config.backup.outputDir || './backups');
+    
+    if (validBackups.length === 0) {
+      console.error(chalk.red('❌ Nenhum backup válido encontrado'));
       console.log(chalk.yellow('💡 Execute primeiro: npx smoonb backup'));
       process.exit(1);
     }
-
-    // Seleção interativa do backup
-    const selectedBackup = await selectBackup(backups);
     
-    console.log(chalk.blue(`🚀 Iniciando restauração do backup: ${selectedBackup.name}`));
-    console.log(chalk.blue(`🎯 Database destino: ${databaseUrl.replace(/:[^:]*@/, ':***@')}`));
-
-    // Verificar se é clean restore
-    if (config.restore.cleanRestore) {
-      await checkCleanRestore(databaseUrl);
+    // 2. Selecionar backup interativamente
+    const selectedBackup = await selectBackupInteractive(validBackups);
+    
+    // 3. Perguntar quais componentes restaurar
+    const components = await askRestoreComponents(selectedBackup.path);
+    
+    // 4. Mostrar resumo
+    showRestoreSummary(selectedBackup, components, targetProject);
+    
+    // 5. Confirmar execução
+    const confirmed = await confirmExecution();
+    if (!confirmed) {
+      console.log(chalk.yellow('Restauração cancelada.'));
+      process.exit(0);
     }
-
-    // Executar restauração
-    await performRestore(selectedBackup.path, databaseUrl);
-
-    // Verificação pós-restore
-    if (config.restore.verifyAfterRestore) {
-      console.log(chalk.blue('\n🔍 Executando verificação pós-restore...'));
-      console.log(chalk.yellow('💡 Execute manualmente: npx smoonb check'));
+    
+    // 6. Executar restauração
+    console.log(chalk.blue('\n🚀 Iniciando restauração...'));
+    
+    // 6.1 Database
+    await restoreDatabaseGz(
+      path.join(selectedBackup.path, selectedBackup.backupFile),
+      targetProject.targetDatabaseUrl
+    );
+    
+    // 6.2 Edge Functions (se selecionado)
+    if (components.edgeFunctions) {
+      await restoreEdgeFunctions(selectedBackup.path, targetProject);
     }
-
-    console.log(chalk.green('\n🎉 Restauração concluída com sucesso!'));
-
+    
+    // 6.3 Storage Buckets (se selecionado)
+    if (components.storage) {
+      await restoreStorageBuckets(selectedBackup.path, targetProject);
+    }
+    
+    // 6.4 Auth Settings (se selecionado)
+    if (components.authSettings) {
+      await restoreAuthSettings(selectedBackup.path, targetProject);
+    }
+    
+    // 6.5 Database Settings (se selecionado)
+    if (components.databaseSettings) {
+      await restoreDatabaseSettings(selectedBackup.path, targetProject);
+    }
+    
+    // 6.6 Realtime Settings (se selecionado)
+    if (components.realtimeSettings) {
+      await restoreRealtimeSettings(selectedBackup.path, targetProject);
+    }
+    
+    console.log(chalk.green('\n🎉 Restauração completa finalizada!'));
+    
   } catch (error) {
     console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
     process.exit(1);
   }
 };
 
-// Listar backups disponíveis
-async function listAvailableBackups(backupsDir) {
+// Listar backups válidos (apenas com .backup.gz)
+async function listValidBackups(backupsDir) {
   if (!fs.existsSync(backupsDir)) {
     return [];
   }
 
   const items = fs.readdirSync(backupsDir, { withFileTypes: true });
-  const backups = [];
+  const validBackups = [];
 
   for (const item of items) {
     if (item.isDirectory() && item.name.startsWith('backup-')) {
       const backupPath = path.join(backupsDir, item.name);
-      const manifestPath = path.join(backupPath, 'backup-manifest.json');
+      const files = fs.readdirSync(backupPath);
+      const backupFile = files.find(file => file.endsWith('.backup.gz'));
       
-      let manifest = null;
-      if (fs.existsSync(manifestPath)) {
-        try {
-          manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-        } catch (error) {
-          console.warn(chalk.yellow(`⚠️ Erro ao ler manifesto: ${item.name}`));
+      if (backupFile) {
+        const manifestPath = path.join(backupPath, 'backup-manifest.json');
+        let manifest = null;
+        
+        if (fs.existsSync(manifestPath)) {
+          try {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+          } catch (error) {
+            // Ignorar erro de leitura do manifest
+          }
         }
-      }
-
-      const stats = fs.statSync(backupPath);
-      
-      backups.push({
-        name: item.name,
-        path: backupPath,
-        created: manifest?.created_at || stats.birthtime.toISOString(),
-        projectId: manifest?.project_id || 'Desconhecido',
-        size: getDirectorySize(backupPath),
-        manifest: manifest
-      });
-    }
-  }
-
-  // Ordenar por data de criação (mais recente primeiro)
-  return backups.sort((a, b) => new Date(b.created) - new Date(a.created));
-}
 
-// Calcular tamanho do diretório
-function getDirectorySize(dirPath) {
-  let totalSize = 0;
-  
-  function calculateSize(itemPath) {
-    const stats = fs.statSync(itemPath);
-    
-    if (stats.isDirectory()) {
-      const items = fs.readdirSync(itemPath);
-      for (const item of items) {
-        calculateSize(path.join(itemPath, item));
+        const stats = fs.statSync(path.join(backupPath, backupFile));
+        
+        validBackups.push({
+          name: item.name,
+          path: backupPath,
+          backupFile: backupFile,
+          created: manifest?.created_at || stats.birthtime.toISOString(),
+          projectId: manifest?.project_id || 'Desconhecido',
+          size: formatBytes(stats.size),
+          manifest: manifest
+        });
       }
-    } else {
-      totalSize += stats.size;
     }
   }
-  
-  try {
-    calculateSize(dirPath);
-  } catch (error) {
-    // Ignorar erros de acesso
-  }
-  
-  return formatBytes(totalSize);
+
+  return validBackups.sort((a, b) => new Date(b.created) - new Date(a.created));
 }
 
-// Formatar bytes em formato legível
+// Formatar bytes
 function formatBytes(bytes) {
   if (bytes === 0) return '0 Bytes';
-  
   const k = 1024;
   const sizes = ['Bytes', 'KB', 'MB', 'GB'];
   const i = Math.floor(Math.log(bytes) / Math.log(k));
-  
   return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 
-// Seleção interativa do backup
-async function selectBackup(backups) {
+// Seleção interativa de backup
+async function selectBackupInteractive(backups) {
   console.log(chalk.blue('\n📋 Backups disponíveis:'));
   console.log(chalk.blue('═'.repeat(80)));
   
-  const choices = backups.map((backup, index) => {
+  backups.forEach((backup, index) => {
     const date = new Date(backup.created).toLocaleString('pt-BR');
     const projectInfo = backup.projectId !== 'Desconhecido' ? ` (${backup.projectId})` : '';
     
-    return {
-      name: `${index + 1}. ${backup.name}${projectInfo}\n   📅 ${date} | 📦 ${backup.size}`,
-      value: backup,
-      short: backup.name
-    };
+    console.log(`${index + 1}. ${backup.name}${projectInfo}`);
+    console.log(`   📅 ${date} | 📦 ${backup.size}`);
+    console.log('');
+  });
+  
+  const readline = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
   });
+  
+  const question = (query) => new Promise(resolve => readline.question(query, resolve));
+  
+  const choice = await question(`\nDigite o número do backup para restaurar (1-${backups.length}): `);
+  readline.close();
+  
+  const backupIndex = parseInt(choice) - 1;
+  
+  if (backupIndex < 0 || backupIndex >= backups.length) {
+    throw new Error('Número inválido');
+  }
+  
+  return backups[backupIndex];
+}
 
-  const { selectedBackup } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'selectedBackup',
-      message: 'Selecione o backup para restaurar:',
-      choices: choices,
-      pageSize: 10
-    }
-  ]);
+// Perguntar quais componentes restaurar
+async function askRestoreComponents(backupPath) {
+  const components = {
+    edgeFunctions: true,
+    storage: false,
+    authSettings: false,
+    databaseSettings: false,
+    realtimeSettings: false
+  };
+  
+  const readline = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const question = (query) => new Promise(resolve => readline.question(query, resolve));
+  
+  console.log(chalk.blue('\n📦 Selecione os componentes para restaurar:'));
+  
+  // Edge Functions
+  const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
+  if (fs.existsSync(edgeFunctionsDir) && fs.readdirSync(edgeFunctionsDir).length > 0) {
+    const edgeChoice = await question('Deseja restaurar Edge Functions? (S/n): ');
+    components.edgeFunctions = edgeChoice.toLowerCase() !== 'n';
+  }
+  
+  // Storage Buckets
+  const storageDir = path.join(backupPath, 'storage');
+  if (fs.existsSync(storageDir) && fs.readdirSync(storageDir).length > 0) {
+    const storageChoice = await question('Deseja restaurar Storage Buckets? (s/N): ');
+    components.storage = storageChoice.toLowerCase() === 's';
+  }
+  
+  // Auth Settings
+  if (fs.existsSync(path.join(backupPath, 'auth-settings.json'))) {
+    const authChoice = await question('Deseja restaurar Auth Settings? (s/N): ');
+    components.authSettings = authChoice.toLowerCase() === 's';
+  }
+  
+  // Database Settings
+  const dbSettingsFiles = fs.readdirSync(backupPath)
+    .filter(file => file.startsWith('database-settings-') && file.endsWith('.json'));
+  if (dbSettingsFiles.length > 0) {
+    const dbChoice = await question('Deseja restaurar Database Extensions and Settings? (s/N): ');
+    components.databaseSettings = dbChoice.toLowerCase() === 's';
+  }
+  
+  // Realtime Settings
+  if (fs.existsSync(path.join(backupPath, 'realtime-settings.json'))) {
+    const realtimeChoice = await question('Deseja restaurar Realtime Settings? (s/N): ');
+    components.realtimeSettings = realtimeChoice.toLowerCase() === 's';
+  }
+  
+  readline.close();
+  return components;
+}
 
-  return selectedBackup;
+// Mostrar resumo da restauração
+function showRestoreSummary(backup, components, targetProject) {
+  console.log(chalk.blue('\n📋 Resumo da Restauração:'));
+  console.log(chalk.blue('═'.repeat(80)));
+  console.log(chalk.cyan(`📦 Backup: ${backup.name}`));
+  console.log(chalk.cyan(`📤 Projeto Origem: ${backup.projectId}`));
+  console.log(chalk.cyan(`📥 Projeto Destino: ${targetProject.targetProjectId}`));
+  console.log('');
+  console.log(chalk.cyan('Componentes que serão restaurados:'));
+  console.log('');
+  
+  console.log('✅ Database (psql -f via Docker)');
+  
+  if (components.edgeFunctions) {
+    const edgeFunctionsDir = path.join(backup.path, 'edge-functions');
+    const functions = fs.readdirSync(edgeFunctionsDir).filter(item => 
+      fs.statSync(path.join(edgeFunctionsDir, item)).isDirectory()
+    );
+    console.log(`⚡ Edge Functions: ${functions.length} function(s)`);
+    functions.forEach(func => console.log(`   - ${func}`));
+  }
+  
+  if (components.storage) {
+    console.log('📦 Storage Buckets: Restaurar buckets e objetos');
+  }
+  
+  if (components.authSettings) {
+    console.log('🔐 Auth Settings: Restaurar configurações de autenticação');
+  }
+  
+  if (components.databaseSettings) {
+    console.log('🔧 Database Settings: Restaurar extensões e configurações');
+  }
+  
+  if (components.realtimeSettings) {
+    console.log('🔄 Realtime Settings: Restaurar configurações do Realtime');
+  }
+  
+  console.log('');
 }
 
-// Verificar se é possível fazer clean restore
-async function checkCleanRestore(databaseUrl) {
+// Confirmar execução
+async function confirmExecution() {
+  const readline = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const question = (query) => new Promise(resolve => readline.question(query, resolve));
+  
+  const confirm = await question('Deseja continuar com a restauração? (s/N): ');
+  readline.close();
+  
+  return confirm.toLowerCase() === 's';
+}
+
+// Restaurar Database via psql (conforme documentação oficial Supabase: https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore)
+async function restoreDatabaseGz(backupFilePath, targetDatabaseUrl) {
+  console.log(chalk.blue('📊 Restaurando Database...'));
+  console.log(chalk.gray('   - Descompactando backup (se necessário)...'));
+  
   try {
-    console.log(chalk.blue('🔍 Verificando se database está vazia...'));
+    const { execSync } = require('child_process');
     
-    // Verificar se existem tabelas no schema public
-    const checkQuery = `
-      SELECT COUNT(*) as table_count 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public' AND table_type = 'BASE TABLE';
-    `;
+    const backupDirAbs = path.resolve(path.dirname(backupFilePath));
+    const fileName = path.basename(backupFilePath);
+    let uncompressedFile = fileName;
     
-    const { stdout } = await runCommand(
-      `psql "${databaseUrl}" -t -c "${checkQuery}"`
-    );
+    // Descompactar .gz se necessário
+    if (fileName.endsWith('.gz')) {
+      console.log(chalk.gray('   - Extraindo arquivo .gz...'));
+      const unzipCmd = [
+        'docker run --rm',
+        `-v "${backupDirAbs}:/host"`,
+        'postgres:17 gunzip /host/' + fileName
+      ].join(' ');
+      
+      execSync(unzipCmd, { stdio: 'pipe' });
+      uncompressedFile = fileName.replace('.gz', '');
+      console.log(chalk.gray('   - Arquivo descompactado: ' + uncompressedFile));
+    }
     
-    const tableCount = parseInt(stdout.trim());
+    // Extrair credenciais da URL de conexão
+    const urlMatch = targetDatabaseUrl.match(/postgresql:\/\/([^@:]+):([^@]+)@(.+)$/);
     
-    if (tableCount > 0) {
-      console.error(chalk.red('❌ Database não está vazia!'));
-      console.log(chalk.yellow('💡 Para clean restore, a database deve estar vazia'));
-      console.log(chalk.yellow('💡 Opções:'));
-      console.log(chalk.yellow('  1. Criar uma nova database'));
-      console.log(chalk.yellow('  2. Desabilitar cleanRestore no .smoonbrc'));
-      console.log(chalk.yellow('  3. Limpar manualmente a database'));
-      process.exit(1);
+    if (!urlMatch) {
+      throw new Error('Database URL inválida. Formato esperado: postgresql://user:password@host/database');
     }
     
-    console.log(chalk.green('✅ Database está vazia, prosseguindo com clean restore'));
+    // Comando psql conforme documentação oficial Supabase
+    // Formato: psql -d [CONNECTION_STRING] -f /file/path
+    // Referência: https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore
+    const restoreCmd = [
+      'docker run --rm --network host',
+      `-v "${backupDirAbs}:/host"`,
+      `-e PGPASSWORD="${encodeURIComponent(urlMatch[2])}"`,
+      'postgres:17 psql',
+      `-d "${targetDatabaseUrl}"`,
+      `-f /host/${uncompressedFile}`
+    ].join(' ');
     
-  } catch (error) {
-    console.log(chalk.yellow(`⚠️ Não foi possível verificar database: ${error.message}`));
-    console.log(chalk.yellow('💡 Prosseguindo com restauração...'));
-  }
-}
-
-// Executar restauração usando psql
-async function performRestore(backupDir, databaseUrl) {
-  const sqlFiles = ['roles.sql', 'schema.sql', 'data.sql'];
-  
-  for (const sqlFile of sqlFiles) {
-    const filePath = path.join(backupDir, sqlFile);
+    console.log(chalk.gray('   - Executando psql via Docker...'));
+    console.log(chalk.gray('   ℹ️ 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'));
     
-    if (!fs.existsSync(filePath)) {
-      console.log(chalk.yellow(`⚠️ Arquivo ${sqlFile} não encontrado, pulando...`));
-      continue;
-    }
+    // Executar comando de restauração
+    execSync(restoreCmd, { stdio: 'inherit', encoding: 'utf8' });
     
-    console.log(chalk.blue(`📄 Executando ${sqlFile}...`));
+    console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
+    console.log(chalk.gray('   ℹ️ Erros "already exists" são normais e não afetam a restauração'));
     
-    try {
-      let command;
-      if (sqlFile === 'data.sql') {
-        // Para dados, usar single-transaction
-        command = `psql "${databaseUrl}" -v ON_ERROR_STOP=1 --single-transaction -f "${filePath}"`;
-      } else {
-        // Para roles e schema, usar ON_ERROR_STOP
-        command = `psql "${databaseUrl}" -v ON_ERROR_STOP=1 -f "${filePath}"`;
-      }
-      
-      const { stdout, stderr } = await runCommand(command);
-      
-      if (stderr && !stderr.includes('NOTICE')) {
-        console.log(chalk.yellow(`⚠️ Avisos em ${sqlFile}: ${stderr}`));
-      }
-      
-      console.log(chalk.green(`✅ ${sqlFile} executado com sucesso`));
-      
-    } catch (error) {
-      throw new Error(`Falha ao executar ${sqlFile}: ${error.message}`);
+  } catch (error) {
+    // Erros esperados conforme documentação oficial Supabase
+    // Referência: https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore#common-errors
+    if (error.message.includes('already exists') || 
+        error.message.includes('constraint') ||
+        error.message.includes('duplicate') ||
+        error.stdout?.includes('already exists')) {
+      console.log(chalk.yellow('   ⚠️ Erros esperados encontrados (conforme documentação Supabase)'));
+      console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
+      console.log(chalk.gray('   ℹ️ Erros são ignorados pois são comandos de CREATE que já existem'));
+    } else {
+      console.error(chalk.red(`   ❌ Erro inesperado na restauração: ${error.message}`));
+      throw error;
     }
   }
-}
+}
+
+// Restaurar Edge Functions (placeholder - implementar via Management API)
+async function restoreEdgeFunctions(backupPath, targetProject) {
+  console.log(chalk.blue('⚡ Restaurando Edge Functions...'));
+  console.log(chalk.yellow('   ℹ️ Deploy de Edge Functions via Management API ainda não implementado'));
+  // TODO: Implementar deploy via Supabase Management API
+}
+
+// Restaurar Storage Buckets (placeholder)
+async function restoreStorageBuckets(backupPath, targetProject) {
+  console.log(chalk.blue('📦 Restaurando Storage Buckets...'));
+  console.log(chalk.yellow('   ℹ️ Restauração de Storage Buckets ainda não implementado'));
+  // TODO: Implementar restauração via Management API
+}
+
+// Restaurar Auth Settings (placeholder)
+async function restoreAuthSettings(backupPath, targetProject) {
+  console.log(chalk.blue('🔐 Restaurando Auth Settings...'));
+  console.log(chalk.yellow('   ℹ️ Restauração de Auth Settings ainda não implementado'));
+  // TODO: Implementar via Management API
+}
+
+// Restaurar Database Settings (placeholder)
+async function restoreDatabaseSettings(backupPath, targetProject) {
+  console.log(chalk.blue('🔧 Restaurando Database Settings...'));
+  console.log(chalk.yellow('   ℹ️ Restauração de Database Settings ainda não implementado'));
+  // TODO: Aplicar extensões e configurações via SQL
+}
+
+// Restaurar Realtime Settings (placeholder)
+async function restoreRealtimeSettings(backupPath, targetProject) {
+  console.log(chalk.blue('🔄 Restaurando Realtime Settings...'));
+  console.log(chalk.yellow('   ℹ️ Realtime Settings requerem configuração manual no Dashboard'));
+  // TODO: Adicionar instruções de configuração manual
+}

package/src/utils/config.js

@@ -133,8 +133,37 @@ async function saveConfig(config, targetPath = null) {
   await fs.promises.writeFile(configPath, jsonContent, 'utf8');
 }
 
+/**
+ * Obtém configuração do projeto source
+ * @param {object} config - Configuração carregada
+ * @returns {object} - Configuração do projeto source
+ */
+function getSourceProject(config) {
+  if (config.projects && config.projects.source) {
+    return config.projects.source;
+  }
+  // Fallback para estrutura antiga
+  return config.supabase;
+}
+
+/**
+ * Obtém configuração do projeto target
+ * @param {object} config - Configuração carregada
+ * @returns {object} - Configuração do projeto target
+ */
+function getTargetProject(config) {
+  // Tenta restaurar.targetProject (nova estrutura)
+  if (config.restore?.targetProject) {
+    return config.restore.targetProject;
+  }
+  
+  throw new Error('Projeto destino não configurado. Configure "targetProject" em restore no .smoonbrc');
+}
+
 module.exports = {
   readConfig,
   validateFor,
-  saveConfig
+  saveConfig,
+  getSourceProject,
+  getTargetProject
 };