smoonb 0.0.47 → 0.0.48

package/src/commands/restore/index.js

@@ -0,0 +1,190 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const inquirer = require('inquirer');
+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');
+
+// Importar todas as etapas
+const step00BackupSelection = require('./steps/00-backup-selection');
+const step01ComponentsSelection = require('./steps/01-components-selection');
+const step02Confirmation = require('./steps/02-confirmation');
+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 {
+    // Consentimento para leitura e escrita do .env.local
+    console.log(chalk.yellow('⚠️  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.'));
+    const consent = await inquirer.prompt([{ type: 'confirm', name: 'ok', message: 'Você consente em prosseguir (S/n):', default: true }]);
+    if (!consent.ok) {
+      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
+    showRestoreSummary(selectedBackup, components, targetProject);
+    
+    // 5. Confirmar execução
+    const confirmed = await step02Confirmation();
+    if (!confirmed) {
+      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,84 @@
+const path = require('path');
+const fs = require('fs');
+const inquirer = require('inquirer');
+
+/**
+ * Etapa 1: Perguntar quais componentes restaurar
+ */
+module.exports = async (backupPath) => {
+  const questions = [];
+  
+  // Database
+  questions.push({
+    type: 'confirm',
+    name: 'restoreDatabase',
+    message: 'Deseja restaurar Database (S/n):',
+    default: true
+  });
+  
+  // Edge Functions
+  const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
+  if (fs.existsSync(edgeFunctionsDir) && fs.readdirSync(edgeFunctionsDir).length > 0) {
+    questions.push({
+      type: 'confirm',
+      name: 'restoreEdgeFunctions',
+      message: 'Deseja restaurar Edge Functions (S/n):',
+      default: true
+    });
+  }
+  
+  // Auth Settings
+  if (fs.existsSync(path.join(backupPath, 'auth-settings.json'))) {
+    questions.push({
+      type: 'confirm',
+      name: 'restoreAuthSettings',
+      message: 'Deseja restaurar Auth Settings (s/N):',
+      default: false
+    });
+  }
+  
+  // Storage Buckets
+  const storageDir = path.join(backupPath, 'storage');
+  if (fs.existsSync(storageDir) && fs.readdirSync(storageDir).length > 0) {
+    questions.push({
+      type: 'confirm',
+      name: 'restoreStorage',
+      message: 'Deseja ver informações de Storage Buckets (s/N):',
+      default: false
+    });
+  }
+  
+  // Database Extensions and Settings
+  const dbSettingsFiles = fs.readdirSync(backupPath)
+    .filter(file => file.startsWith('database-settings-') && file.endsWith('.json'));
+  if (dbSettingsFiles.length > 0) {
+    questions.push({
+      type: 'confirm',
+      name: 'restoreDatabaseSettings',
+      message: 'Deseja restaurar Database Extensions and Settings (s/N):',
+      default: false
+    });
+  }
+  
+  // Realtime Settings
+  if (fs.existsSync(path.join(backupPath, 'realtime-settings.json'))) {
+    questions.push({
+      type: 'confirm',
+      name: 'restoreRealtimeSettings',
+      message: 'Deseja restaurar Realtime Settings (s/N):',
+      default: false
+    });
+  }
+  
+  const answers = await inquirer.prompt(questions);
+  
+  return {
+    database: answers.restoreDatabase,
+    edgeFunctions: answers.restoreEdgeFunctions || false,
+    storage: answers.restoreStorage || false,
+    authSettings: answers.restoreAuthSettings || false,
+    databaseSettings: answers.restoreDatabaseSettings || false,
+    realtimeSettings: answers.restoreRealtimeSettings || false
+  };
+};
+

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

@@ -0,0 +1,19 @@
+const readline = require('readline');
+
+/**
+ * Etapa 2: Confirmar execução
+ */
+module.exports = async () => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const question = (query) => new Promise(resolve => rl.question(query, resolve));
+  
+  const confirm = await question('Deseja continuar com a restauração? (s/N): ');
+  rl.close();
+  
+  return confirm.toLowerCase() === 's';
+};
+

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 (cleanError) {
+      // 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 (linkError) {
+      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 (cleanError) {
+      // 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}`));
+  }
+};
+