smoonb 0.0.47 → 0.0.49

package/src/commands/restore/index.js

@@ -0,0 +1,206 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { readEnvFile, writeEnvFile, backupEnvFile } = require('../../utils/env');
+const { saveEnvMap } = require('../../utils/envMap');
+const { mapEnvVariablesInteractively } = require('../../interactive/envMapper');
+const { showBetaBanner } = require('../../utils/banner');
+const { listValidBackups, showRestoreSummary } = require('./utils');
+const { confirm } = require('../../utils/prompt');
+const step00DockerValidation = require('../backup/steps/00-docker-validation');
+
+// Importar todas as etapas
+const step00BackupSelection = require('./steps/00-backup-selection');
+const step01ComponentsSelection = require('./steps/01-components-selection');
+const step03Database = require('./steps/03-database');
+const step04EdgeFunctions = require('./steps/04-edge-functions');
+const step05AuthSettings = require('./steps/05-auth-settings');
+const step06Storage = require('./steps/06-storage');
+const step07DatabaseSettings = require('./steps/07-database-settings');
+const step08RealtimeSettings = require('./steps/08-realtime-settings');
+
+module.exports = async (_options) => {
+  showBetaBanner();
+  
+  try {
+    // Executar validação Docker ANTES de tudo
+    await step00DockerValidation();
+
+    // Consentimento para leitura e escrita do .env.local
+    console.log(chalk.yellow('\n⚠️  O smoonb irá ler e escrever o arquivo .env.local localmente.'));
+    console.log(chalk.yellow('   Um backup automático do .env.local será criado antes de qualquer alteração.'));
+    console.log(chalk.yellow('   Vamos mapear suas variáveis de ambiente para garantir que todas as chaves necessárias'));
+    console.log(chalk.yellow('   estejam presentes e com os valores corretos do projeto de destino.'));
+    const consentOk = await confirm('Você consente em prosseguir', true);
+    if (!consentOk) {
+      console.log(chalk.red('🚫 Operação cancelada pelo usuário.'));
+      process.exit(1);
+    }
+
+    // Preparar diretório de processo restore-YYYY-...
+    const rootBackupsDir = path.join(process.cwd(), 'backups');
+    const now = new Date();
+    const ts = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,'0')}-${String(now.getDate()).padStart(2,'0')}-${String(now.getHours()).padStart(2,'0')}-${String(now.getMinutes()).padStart(2,'0')}-${String(now.getSeconds()).padStart(2,'0')}`;
+    const processDir = path.join(rootBackupsDir, `restore-${ts}`);
+    fs.mkdirSync(path.join(processDir, 'env'), { recursive: true });
+
+    // Backup do .env.local
+    const envPath = path.join(process.cwd(), '.env.local');
+    const envBackupPath = path.join(processDir, 'env', '.env.local');
+    await backupEnvFile(envPath, envBackupPath);
+    console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+
+    // Leitura e mapeamento interativo
+    const currentEnv = await readEnvFile(envPath);
+    const expectedKeys = [
+      'NEXT_PUBLIC_SUPABASE_URL',
+      'NEXT_PUBLIC_SUPABASE_ANON_KEY',
+      'SUPABASE_SERVICE_ROLE_KEY',
+      'SUPABASE_DB_URL',
+      'SUPABASE_PROJECT_ID',
+      'SUPABASE_ACCESS_TOKEN',
+      'SMOONB_OUTPUT_DIR'
+    ];
+    const { finalEnv, dePara } = await mapEnvVariablesInteractively(currentEnv, expectedKeys);
+    await writeEnvFile(envPath, finalEnv);
+    await saveEnvMap(dePara, path.join(processDir, 'env', 'env-map.json'));
+    console.log(chalk.green('✅ .env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.'));
+
+    // Resolver valores esperados a partir do de-para
+    function getValue(expectedKey) {
+      const clientKey = Object.keys(dePara).find(k => dePara[k] === expectedKey);
+      return clientKey ? finalEnv[clientKey] : '';
+    }
+
+    // Construir targetProject a partir do .env.local mapeado
+    const targetProject = {
+      targetProjectId: getValue('SUPABASE_PROJECT_ID'),
+      targetUrl: getValue('NEXT_PUBLIC_SUPABASE_URL'),
+      targetAnonKey: getValue('NEXT_PUBLIC_SUPABASE_ANON_KEY'),
+      targetServiceKey: getValue('SUPABASE_SERVICE_ROLE_KEY'),
+      targetDatabaseUrl: getValue('SUPABASE_DB_URL'),
+      targetAccessToken: getValue('SUPABASE_ACCESS_TOKEN')
+    };
+    
+    console.log(chalk.blue(`📁 Buscando backups em: ${getValue('SMOONB_OUTPUT_DIR') || './backups'}`));
+    
+    // 1. Listar backups válidos (.backup.gz)
+    const validBackups = await listValidBackups(getValue('SMOONB_OUTPUT_DIR') || './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);
+    }
+    
+    // 2. Selecionar backup interativamente
+    const selectedBackup = await step00BackupSelection(validBackups);
+    
+    // 3. Perguntar quais componentes restaurar
+    const components = await step01ComponentsSelection(selectedBackup.path);
+    
+    // Validar que pelo menos um componente foi selecionado
+    if (!Object.values(components).some(Boolean)) {
+      console.error(chalk.red('\n❌ Nenhum componente selecionado para restauração!'));
+      process.exit(1);
+    }
+    
+    // 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`));
+    
+    // Mostrar resumo técnico adicional
+    showRestoreSummary(selectedBackup, components, targetProject);
+    
+    // 5. Confirmar execução
+    const finalOk = await confirm('Deseja iniciar a restauração com estas configurações?', true);
+    if (!finalOk) {
+      console.log(chalk.yellow('🚫 Restauração cancelada.'));
+      process.exit(0);
+    }
+    
+    // 6. Executar restauração
+    console.log(chalk.blue('\n🚀 Iniciando restauração...'));
+    
+    // 6.1 Database (se selecionado)
+    if (components.database) {
+      await step03Database({
+        backupFilePath: path.join(selectedBackup.path, selectedBackup.backupFile),
+        targetDatabaseUrl: targetProject.targetDatabaseUrl
+      });
+    }
+    
+    // 6.2 Edge Functions (se selecionado)
+    if (components.edgeFunctions) {
+      await step04EdgeFunctions({
+        backupPath: selectedBackup.path,
+        targetProject
+      });
+    }
+    
+    // 6.3 Auth Settings (se selecionado)
+    if (components.authSettings) {
+      await step05AuthSettings({
+        backupPath: selectedBackup.path,
+        targetProject
+      });
+    }
+    
+    // 6.4 Storage Buckets (se selecionado)
+    if (components.storage) {
+      await step06Storage({
+        backupPath: selectedBackup.path
+      });
+    }
+    
+    // 6.5 Database Settings (se selecionado)
+    if (components.databaseSettings) {
+      await step07DatabaseSettings({
+        backupPath: selectedBackup.path,
+        targetProject
+      });
+    }
+    
+    // 6.6 Realtime Settings (se selecionado)
+    if (components.realtimeSettings) {
+      await step08RealtimeSettings({
+        backupPath: selectedBackup.path,
+        targetProject
+      });
+    }
+    
+    // report.json de restauração
+    const report = {
+      process: 'restore',
+      created_at: new Date().toISOString(),
+      target_project_id: targetProject.targetProjectId,
+      assets: {
+        env: path.join(processDir, 'env', '.env.local'),
+        env_map: path.join(processDir, 'env', 'env-map.json')
+      },
+      components: components,
+      notes: [
+        'supabase/functions limpo antes e depois do deploy (se Edge Functions selecionado)'
+      ]
+    };
+    try {
+      fs.writeFileSync(path.join(processDir, 'report.json'), JSON.stringify(report, null, 2));
+    } catch {
+      // silencioso
+    }
+
+    console.log(chalk.green('\n🎉 Restauração completa finalizada!'));
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
+    process.exit(1);
+  }
+};
+

package/src/commands/restore/steps/00-backup-selection.js

@@ -0,0 +1,38 @@
+const chalk = require('chalk');
+const readline = require('readline');
+
+/**
+ * Etapa 0: Seleção interativa de backup
+ */
+module.exports = async (backups) => {
+  console.log(chalk.blue('\n📋 Backups disponíveis:'));
+  console.log(chalk.blue('═'.repeat(80)));
+  
+  backups.forEach((backup, index) => {
+    const date = new Date(backup.created).toLocaleString('pt-BR');
+    const projectInfo = backup.projectId !== 'Desconhecido' ? ` (${backup.projectId})` : '';
+    
+    console.log(`${index + 1}. ${backup.name}${projectInfo}`);
+    console.log(`   📅 ${date} | 📦 ${backup.size}`);
+    console.log('');
+  });
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const question = (query) => new Promise(resolve => rl.question(query, resolve));
+  
+  const choice = await question(`\nDigite o número do backup para restaurar (1-${backups.length}): `);
+  rl.close();
+  
+  const backupIndex = parseInt(choice) - 1;
+  
+  if (backupIndex < 0 || backupIndex >= backups.length) {
+    throw new Error('Número inválido');
+  }
+  
+  return backups[backupIndex];
+};
+

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

@@ -0,0 +1,71 @@
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const { confirm } = require('../../utils/prompt');
+
+/**
+ * Etapa 1: Perguntar quais componentes restaurar
+ */
+module.exports = async (backupPath) => {
+  // Database (sempre disponível)
+  const restoreDatabase = await confirm('Deseja restaurar Database', true);
+  
+  // Edge Functions
+  const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
+  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'));
+    restoreEdgeFunctions = await confirm('Deseja restaurar Edge Functions', true);
+  }
+  
+  // Auth Settings
+  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'));
+    restoreAuthSettings = await confirm('Deseja ver as configurações de Auth Settings', true);
+  }
+  
+  // Storage Buckets
+  const storageDir = path.join(backupPath, 'storage');
+  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'));
+    restoreStorage = await confirm('Deseja ver informações de Storage Buckets', true);
+  }
+  
+  // Database Extensions and Settings
+  const dbSettingsFiles = fs.readdirSync(backupPath)
+    .filter(file => file.startsWith('database-settings-') && file.endsWith('.json'));
+  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'));
+    restoreDatabaseSettings = await confirm('Deseja restaurar Database Extensions and Settings', true);
+  }
+  
+  // Realtime Settings
+  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'));
+    restoreRealtimeSettings = await confirm('Deseja ver as configurações de Realtime Settings', true);
+  }
+  
+  return {
+    database: restoreDatabase,
+    edgeFunctions: restoreEdgeFunctions,
+    storage: restoreStorage,
+    authSettings: restoreAuthSettings,
+    databaseSettings: restoreDatabaseSettings,
+    realtimeSettings: restoreRealtimeSettings
+  };
+};
+

package/src/commands/restore/steps/02-confirmation.js

@@ -0,0 +1,14 @@
+// Este arquivo não é mais usado diretamente
+// 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');
+
+/**
+ * Etapa 2: Confirmar execução (LEGACY - não usado mais)
+ * A confirmação agora é feita no index.js após mostrar resumo detalhado
+ */
+module.exports = async () => {
+  return await confirm('Deseja continuar com a restauração?', true);
+};
+

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

@@ -0,0 +1,81 @@
+const chalk = require('chalk');
+const path = require('path');
+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);
+    let uncompressedFile = fileName;
+    
+    // Verificar se é arquivo .backup.gz (compactado) ou .backup (descompactado)
+    if (fileName.endsWith('.backup.gz')) {
+      console.log(chalk.gray('   - Arquivo .backup.gz detectado'));
+      console.log(chalk.gray('   - Extraindo arquivo .gz...'));
+      
+      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));
+    } else if (fileName.endsWith('.backup')) {
+      console.log(chalk.gray('   - Arquivo .backup detectado (já descompactado)'));
+      console.log(chalk.gray('   - Prosseguindo com restauração direta'));
+    } else {
+      throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
+    }
+    
+    // Extrair credenciais da URL de conexão
+    const urlMatch = targetDatabaseUrl.match(/postgresql:\/\/([^@:]+):([^@]+)@(.+)$/);
+    
+    if (!urlMatch) {
+      throw new Error('Database URL inválida. Formato esperado: postgresql://user:password@host/database');
+    }
+    
+    // Comando psql conforme documentação oficial Supabase
+    const restoreCmd = [
+      'docker run --rm --network host',
+      `-v "${backupDirAbs}:/host"`,
+      `-e PGPASSWORD="${encodeURIComponent(urlMatch[2])}"`,
+      'postgres:17 psql',
+      `-d "${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.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'));
+    
+    // Executar comando de restauração
+    execSync(restoreCmd, { stdio: 'inherit', encoding: 'utf8' });
+    
+    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'));
+    
+  } catch (error) {
+    // Erros esperados conforme documentação oficial Supabase
+    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;
+    }
+  }
+};
+

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

@@ -0,0 +1,112 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+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;
+    }
+    
+    const items = await fs.readdir(edgeFunctionsDir);
+    const functions = [];
+    
+    for (const item of items) {
+      const itemPath = path.join(edgeFunctionsDir, item);
+      const stats = await fs.stat(itemPath);
+      if (stats.isDirectory()) {
+        functions.push(item);
+      }
+    }
+    
+    if (functions.length === 0) {
+      console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
+      return;
+    }
+    
+    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
+    
+    // COPIAR Edge Functions de backups/backup-XXX/edge-functions para supabase/functions
+    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
+    
+    // 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...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+      await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+    } catch {
+      // Ignorar erro de limpeza se não existir
+    }
+    
+    // Copiar cada Edge Function para supabase/functions
+    for (const funcName of functions) {
+      const backupFuncPath = path.join(edgeFunctionsDir, funcName);
+      const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
+      
+      console.log(chalk.gray(`   - Copiando ${funcName} para supabase/functions...`));
+      
+      // Copiar recursivamente
+      await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
+    }
+    
+    console.log(chalk.gray(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
+    
+    // Linkar com o projeto destino
+    try {
+      execSync(`supabase link --project-ref ${targetProject.targetProjectId}`, {
+        stdio: 'pipe',
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
+      });
+    } catch {
+      console.log(chalk.yellow('   ⚠️  Link pode já existir, continuando...'));
+    }
+    
+    // Deploy das Edge Functions
+    for (const funcName of functions) {
+      console.log(chalk.gray(`   - Deployando ${funcName}...`));
+      
+      try {
+        execSync(`supabase functions deploy ${funcName}`, {
+          cwd: process.cwd(),
+          stdio: 'pipe',
+          encoding: 'utf8',
+          timeout: 120000,
+          env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
+        });
+        
+        console.log(chalk.green(`   ✅ ${funcName} deployada com sucesso!`));
+      } 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...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+    } catch {
+      // Ignorar erro de limpeza
+    }
+    
+    console.log(chalk.green('   ✅ Edge Functions restauradas com sucesso!'));
+    
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao restaurar Edge Functions: ${error.message}`));
+  }
+};
+

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

@@ -0,0 +1,51 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+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');
+    
+    if (!fs.existsSync(authSettingsPath)) {
+      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Auth encontrada no backup'));
+      return;
+    }
+    
+    const authSettings = JSON.parse(fs.readFileSync(authSettingsPath, 'utf8'));
+    const dashboardUrl = `https://supabase.com/dashboard/project/${targetProject.targetProjectId}/auth/url-config`;
+    
+    console.log(chalk.green('\n   ✅ URL para configuração manual:'));
+    console.log(chalk.cyan(`   ${dashboardUrl}`));
+    console.log(chalk.yellow('\n   📋 Configure manualmente as seguintes opções:'));
+    
+    if (authSettings.settings?.auth_url_config) {
+      Object.entries(authSettings.settings.auth_url_config).forEach(([key, value]) => {
+        console.log(chalk.gray(`   - ${key}: ${value}`));
+      });
+    } else if (authSettings.auth_url_config) {
+      Object.entries(authSettings.auth_url_config).forEach(([key, value]) => {
+        console.log(chalk.gray(`   - ${key}: ${value}`));
+      });
+    }
+    
+    console.log(chalk.yellow('\n   ⚠️  Após configurar, pressione Enter para continuar...'));
+    
+    await inquirer.prompt([{
+      type: 'input',
+      name: 'continue',
+      message: 'Pressione Enter para continuar'
+    }]);
+    
+    console.log(chalk.green('   ✅ Auth Settings processados'));
+    
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao processar Auth Settings: ${error.message}`));
+  }
+};
+

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

@@ -0,0 +1,58 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+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;
+    }
+    
+    const manifestPath = path.join(backupPath, 'backup-manifest.json');
+    let manifest = null;
+    
+    if (fs.existsSync(manifestPath)) {
+      manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    
+    const buckets = manifest?.components?.storage?.buckets || [];
+    
+    if (buckets.length === 0) {
+      console.log(chalk.gray('   ℹ️  Nenhum bucket para restaurar'));
+      return;
+    }
+    
+    console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup`));
+    buckets.forEach(bucket => {
+      console.log(chalk.gray(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
+    });
+    
+    const colabUrl = 'https://colab.research.google.com/github/PLyn/supabase-storage-migrate/blob/main/Supabase_Storage_migration.ipynb';
+    
+    console.log(chalk.yellow('\n   ⚠️  Migração de objetos de Storage requer processo manual'));
+    console.log(chalk.cyan(`   ℹ️  Use o script do Google Colab: ${colabUrl}`));
+    console.log(chalk.gray('\n   📋 Instruções:'));
+    console.log(chalk.gray('   1. Execute o script no Google Colab'));
+    console.log(chalk.gray('   2. Configure as credenciais dos projetos (origem e destino)'));
+    console.log(chalk.gray('   3. Execute a migração'));
+    
+    await inquirer.prompt([{
+      type: 'input',
+      name: 'continue',
+      message: 'Pressione Enter para continuar'
+    }]);
+    
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao processar Storage: ${error.message}`));
+  }
+};
+