smoonb 0.0.34 → 0.0.36

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.34",
+  "version": "0.0.36",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,

package/src/commands/backup.js

@@ -414,23 +414,40 @@ async function backupEdgeFunctionsWithDocker(projectId, accessToken, backupDir)
     let successCount = 0;
     let errorCount = 0;
 
-    // ✅ Baixar cada Edge Function usando Supabase CLI via Docker
+    // ✅ Baixar cada Edge Function DIRETAMENTE para o backup (sem tocar em ./supabase/functions)
     for (const func of functions) {
       try {
         console.log(chalk.gray(`   - Baixando: ${func.name}...`));
         
-        // Usar comando oficial do Supabase CLI via Docker
-        await execAsync(`supabase functions download ${func.name}`, {
-          cwd: process.cwd(),
-          timeout: 60000 // 60 segundos timeout
+        // Criar diretório da função DIRETAMENTE no backup
+        const functionTargetDir = path.join(functionsDir, func.name);
+        await ensureDir(functionTargetDir);
+        
+        // Baixar Edge Function via Supabase CLI DIRETAMENTE para o backup
+        const { execSync } = require('child_process');
+        const tempBackupDir = path.join(backupDir, 'temp-supabase-download');
+        
+        // Criar estrutura temp para download sem contaminar ./supabase/
+        await ensureDir(tempBackupDir);
+        
+        // Download para diretório temporário
+        execSync(`supabase functions download ${func.name}`, {
+          cwd: tempBackupDir,
+          timeout: 60000,
+          stdio: 'pipe'
         });
         
-        // Mover arquivos baixados para o diretório de backup
-        const sourceDir = path.join(process.cwd(), 'supabase', 'functions', func.name);
-        const targetDir = path.join(functionsDir, func.name);
+        // Mover de temp para o backup final
+        const tempFunctionDir = path.join(tempBackupDir, 'supabase', 'functions', func.name);
         
-        if (await fs.access(sourceDir).then(() => true).catch(() => false)) {
-          await copyDir(sourceDir, targetDir);
+        // Verificar se existe usando fs.promises.access
+        try {
+          await fs.access(tempFunctionDir);
+          await copyDir(tempFunctionDir, functionTargetDir);
+          
+          // Limpar diretório temporário
+          await fs.rm(tempBackupDir, { recursive: true, force: true }).catch(() => {});
+          
           console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
           successCount++;
           
@@ -438,7 +455,7 @@ async function backupEdgeFunctionsWithDocker(projectId, accessToken, backupDir)
             name: func.name,
             slug: func.name,
             version: func.version || 'unknown',
-            files: await fs.access(targetDir).then(() => fs.readdir(targetDir)).catch(() => [])
+            files: await fs.readdir(functionTargetDir).catch(() => [])
           });
         } else {
           throw new Error('Diretório não encontrado após download');

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