smoonb 0.0.54 → 0.0.56

package/package.json

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

package/src/commands/backup/index.js

@@ -139,22 +139,22 @@ module.exports = async (options) => {
 
     // Mostrar resumo e pedir confirmação final
     console.log(chalk.cyan('\n📋 RESUMO DAS CONFIGURAÇÕES:\n'));
-    console.log(chalk.gray(`   ✅ Edge Functions: ${flags.includeFunctions ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Edge Functions: ${flags.includeFunctions ? 'Sim' : 'Não'}`));
     if (flags.includeFunctions) {
-      console.log(chalk.gray(`      🗑️  Limpar após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Limpar após backup: ${flags.cleanFunctions ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Supabase .temp: ${flags.includeTemp ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Supabase .temp: ${flags.includeTemp ? 'Sim' : 'Não'}`));
     if (flags.includeTemp) {
-      console.log(chalk.gray(`      🗑️  Apagar após backup: ${flags.cleanTemp ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Apagar após backup: ${flags.cleanTemp ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Migrations: ${flags.includeMigrations ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Migrations: ${flags.includeMigrations ? 'Sim' : 'Não'}`));
     if (flags.includeMigrations) {
-      console.log(chalk.gray(`      🗑️  Apagar após backup: ${flags.cleanMigrations ? 'Sim' : 'Não'}`));
+      console.log(chalk.white(`      🗑️  Apagar após backup: ${flags.cleanMigrations ? 'Sim' : 'Não'}`));
     }
-    console.log(chalk.gray(`   ✅ Storage: ${flags.includeStorage ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   ✅ Auth: ${flags.includeAuth ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   ✅ Realtime: ${flags.includeRealtime ? 'Sim' : 'Não'}`));
-    console.log(chalk.gray(`   📁 Diretório de backup: ${finalBackupDir}\n`));
+    console.log(chalk.white(`   ✅ Storage: ${flags.includeStorage ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Auth: ${flags.includeAuth ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   ✅ Realtime: ${flags.includeRealtime ? 'Sim' : 'Não'}`));
+    console.log(chalk.white(`   📁 Diretório de backup: ${finalBackupDir}\n`));
 
     const finalOk = await confirm('Deseja iniciar o backup com estas configurações?', true);
 
@@ -193,11 +193,13 @@ module.exports = async (options) => {
 
     // Executar todas as etapas na ordem
     console.log(chalk.blue(`📁 Diretório: ${finalBackupDir}`));
-    console.log(chalk.gray(`🐳 Backup via Docker Desktop`));
+    console.log(chalk.white(`🐳 Backup via Docker Desktop`));
 
     // Contar etapas totais para numeração
+    // Etapas fixas: Database, Database Separado, Database Settings, Custom Roles (4)
+    // Etapas condicionais: Auth, Realtime, Storage, Functions, Temp, Migrations
     let stepNumber = 0;
-    const totalSteps = 7 + (flags?.includeAuth ? 1 : 0) + (flags?.includeRealtime ? 1 : 0) + (flags?.includeStorage ? 1 : 0) + (flags?.includeFunctions ? 1 : 0) + (flags?.includeTemp ? 1 : 0) + (flags?.includeMigrations ? 1 : 0);
+    const totalSteps = 4 + (flags?.includeAuth ? 1 : 0) + (flags?.includeRealtime ? 1 : 0) + (flags?.includeStorage ? 1 : 0) + (flags?.includeFunctions ? 1 : 0) + (flags?.includeTemp ? 1 : 0) + (flags?.includeMigrations ? 1 : 0);
 
     // 1. Backup Database via pg_dumpall Docker
     stepNumber++;

package/src/commands/backup/steps/00-docker-validation.js

@@ -8,7 +8,7 @@ const { showDockerMessagesAndExit } = require('../utils');
  */
 module.exports = async () => {
   console.log(chalk.blue('\n🐳 Validação Docker...'));
-  console.log(chalk.gray('🔍 Verificando dependências Docker...'));
+  console.log(chalk.cyan('🔍 Verificando dependências Docker...'));
   
   const backupCapability = await canPerformCompleteBackup();
 
@@ -17,7 +17,7 @@ module.exports = async () => {
   }
   
   console.log(chalk.green('✅ Docker Desktop detectado e funcionando'));
-  console.log(chalk.gray(`🐳 Versão: ${backupCapability.dockerStatus.version}`));
+  console.log(chalk.white(`🐳 Versão: ${backupCapability.dockerStatus.version}`));
   
   return { success: true };
 };

package/src/commands/backup/steps/01-database.js

@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Criando backup completo via pg_dumpall...'));
+    console.log(chalk.white('   - Criando backup completo via pg_dumpall...'));
     
     // Extrair credenciais da databaseUrl
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
@@ -45,7 +45,7 @@ module.exports = async ({ databaseUrl, backupDir }) => {
       `-f /host/${fileName}`
     ].join(' ');
     
-    console.log(chalk.gray('   - Executando pg_dumpall via Docker...'));
+    console.log(chalk.white('   - Executando pg_dumpall via Docker...'));
     execSync(dockerCmd, { stdio: 'pipe' });
     
     // Compactar igual ao Supabase Dashboard

package/src/commands/backup/steps/02-database-separated.js

@@ -8,14 +8,14 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.gray('   - Criando backups SQL separados via Supabase CLI...'));
+    console.log(chalk.white('   - Criando backups SQL separados via Supabase CLI...'));
     
     const dbUrl = databaseUrl;
     const files = [];
     let totalSizeKB = 0;
     
     // 1. Backup do Schema
-    console.log(chalk.gray('   - Exportando schema...'));
+    console.log(chalk.white('   - Exportando schema...'));
     const schemaFile = path.join(backupDir, 'schema.sql');
     
     try {
@@ -33,7 +33,7 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     }
     
     // 2. Backup dos Dados
-    console.log(chalk.gray('   - Exportando dados...'));
+    console.log(chalk.white('   - Exportando dados...'));
     const dataFile = path.join(backupDir, 'data.sql');
     
     try {
@@ -51,7 +51,7 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     }
     
     // 3. Backup dos Roles
-    console.log(chalk.gray('   - Exportando roles...'));
+    console.log(chalk.white('   - Exportando roles...'));
     const rolesFile = path.join(backupDir, 'roles.sql');
     
     try {

package/src/commands/backup/steps/03-database-settings.js

@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
  */
 module.exports = async ({ databaseUrl, projectId, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Capturando Database Extensions and Settings...'));
+    console.log(chalk.white('   - Capturando Database Extensions and Settings...'));
     
     // Extrair credenciais da databaseUrl
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
@@ -125,7 +125,7 @@ AND EXISTS (
       '-A'  // Unaligned output
     ].join(' ');
     
-    console.log(chalk.gray('   - Executando queries de configurações via Docker...'));
+    console.log(chalk.white('   - Executando queries de configurações via Docker...'));
     const output = execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
     
     // Processar output e criar JSON estruturado

package/src/commands/backup/steps/04-auth-settings.js

@@ -7,7 +7,7 @@ const { writeJson } = require('../../../utils/fsx');
  */
 module.exports = async ({ projectId, accessToken, backupDir }) => {
   try {
-    console.log(chalk.gray('   - Exportando configurações de Auth via Management API...'));
+    console.log(chalk.white('   - Exportando configurações de Auth via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const authResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/config/auth`, {

package/src/commands/backup/steps/05-realtime-settings.js

@@ -8,7 +8,7 @@ const { captureRealtimeSettings } = require('../../../utils/realtime-settings');
  */
 module.exports = async ({ projectId, backupDir, options }) => {
   try {
-    console.log(chalk.gray('   - Capturando Realtime Settings interativamente...'));
+    console.log(chalk.white('   - Capturando Realtime Settings interativamente...'));
     
     const result = await captureRealtimeSettings(projectId, backupDir, options?.skipRealtime);
     

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

@@ -10,7 +10,7 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
 
-    console.log(chalk.gray('   - Listando buckets de Storage via Management API...'));
+    console.log(chalk.white('   - Listando buckets de Storage via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets`, {
@@ -28,20 +28,20 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
     const buckets = await storageResponse.json();
 
     if (!buckets || buckets.length === 0) {
-      console.log(chalk.gray('   - Nenhum bucket encontrado'));
+      console.log(chalk.white('   - Nenhum bucket encontrado'));
       await writeJson(path.join(storageDir, 'README.md'), {
         message: 'Nenhum bucket de Storage encontrado neste projeto'
       });
       return { success: true, buckets: [] };
     }
 
-    console.log(chalk.gray(`   - Encontrados ${buckets.length} buckets`));
+    console.log(chalk.white(`   - Encontrados ${buckets.length} buckets`));
 
     const processedBuckets = [];
 
     for (const bucket of buckets || []) {
       try {
-        console.log(chalk.gray(`   - Processando bucket: ${bucket.name}`));
+        console.log(chalk.white(`   - Processando bucket: ${bucket.name}`));
         
         // Listar objetos do bucket via Management API com Personal Access Token
         const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {

package/src/commands/backup/steps/07-custom-roles.js

@@ -11,7 +11,7 @@ const execAsync = promisify(exec);
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.gray('   - Exportando Custom Roles via Docker...'));
+    console.log(chalk.white('   - Exportando Custom Roles via Docker...'));
     
     const customRolesFile = path.join(backupDir, 'custom-roles.sql');
     

package/src/commands/backup/steps/08-edge-functions.js

@@ -18,12 +18,45 @@ module.exports = async (context) => {
     const dbPassword = extractPasswordFromDbUrl(databaseUrl);
     await ensureCleanLink(projectId, accessToken, dbPassword);
 
-    // Limpar pasta supabase/functions antes do backup
+    // Preparar diretório supabase/functions (criar se não existir, mas não limpar ainda)
     const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
-    await cleanDir(supabaseFunctionsDir);
-    console.log(chalk.gray('   - Pasta supabase/functions limpa.'));
+    
+    // Verificar flag de limpeza antes do backup
+    const shouldCleanAfter = context?.cleanupFlags?.cleanFunctions || false;
+    
+    // Registrar funções que já existiam ANTES do processo (para preservar se necessário)
+    let existingFunctionsBefore = [];
+    try {
+      const existingItems = await fs.readdir(supabaseFunctionsDir);
+      for (const item of existingItems) {
+        const itemPath = path.join(supabaseFunctionsDir, item);
+        const stats = await fs.stat(itemPath);
+        if (stats.isDirectory()) {
+          existingFunctionsBefore.push(item);
+        }
+      }
+    } catch {
+      // Diretório não existe, tudo bem
+      existingFunctionsBefore = [];
+    }
+    
+    // Se o usuário escolheu limpar APÓS, podemos limpar ANTES também para garantir ambiente limpo
+    // Mas se escolheu NÃO limpar, preservamos o que já existe
+    if (shouldCleanAfter) {
+      // Limpar antes se o usuário escolheu limpar após (garante ambiente limpo)
+      await cleanDir(supabaseFunctionsDir);
+      console.log(chalk.white('   - Pasta supabase/functions limpa antes do backup.'));
+    } else {
+      // Apenas garantir que o diretório existe
+      await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+      if (existingFunctionsBefore.length > 0) {
+        console.log(chalk.white(`   - Preservando ${existingFunctionsBefore.length} função(ões) existente(s) na pasta supabase/functions.`));
+      } else {
+        console.log(chalk.white('   - Pasta supabase/functions preparada (será preservada após backup).'));
+      }
+    }
 
-    console.log(chalk.gray('   - Listando Edge Functions via Management API...'));
+    console.log(chalk.white('   - Listando Edge Functions via Management API...'));
     
     // Usar fetch direto para Management API com Personal Access Token
     const functionsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/functions`, {
@@ -41,14 +74,14 @@ module.exports = async (context) => {
     const functions = await functionsResponse.json();
     
     if (!functions || functions.length === 0) {
-      console.log(chalk.gray('   - Nenhuma Edge Function encontrada'));
+      console.log(chalk.white('   - Nenhuma Edge Function encontrada'));
       await writeJson(path.join(functionsDir, 'README.md'), {
         message: 'Nenhuma Edge Function encontrada neste projeto'
       });
       return { success: true, reason: 'no_functions', functions: [] };
     }
 
-    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
+    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
     
     const downloadedFunctions = [];
     let successCount = 0;
@@ -58,7 +91,7 @@ module.exports = async (context) => {
     // Nota: O CLI ignora o cwd e sempre baixa para supabase/functions
     for (const func of functions) {
       try {
-        console.log(chalk.gray(`   - Baixando: ${func.name}...`));
+        console.log(chalk.white(`   - Baixando: ${func.name}...`));
         
         // Criar diretório da função NO BACKUP
         const functionTargetDir = path.join(functionsDir, func.name);
@@ -99,12 +132,16 @@ module.exports = async (context) => {
           console.log(chalk.yellow(`     ⚠️ Nenhum arquivo encontrado em ${tempDownloadDir}`));
         }
         
-        // LIMPAR supabase/functions após copiar
-        try {
-          await fs.rm(tempDownloadDir, { recursive: true, force: true });
-        } catch {
-          // Ignorar erro de limpeza
+        // Limpar função baixada temporariamente APENAS se o usuário escolheu limpar após
+        // Se não escolheu, preservar (pode ser que já existisse antes)
+        if (shouldCleanAfter) {
+          try {
+            await fs.rm(tempDownloadDir, { recursive: true, force: true });
+          } catch {
+            // Ignorar erro de limpeza
+          }
         }
+        // Se shouldCleanAfter = false, manter a função baixada (e qualquer função que já existia)
         
         console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
         successCount++;
@@ -126,12 +163,15 @@ module.exports = async (context) => {
     console.log(chalk.green(`   ✅ Sucessos: ${successCount}`));
     console.log(chalk.green(`   ❌ Erros: ${errorCount}`));
     
-    // Usar flag de limpeza do contexto (já foi perguntado no início)
-    const shouldClean = context?.cleanupFlags?.cleanFunctions || false;
-    
-    if (shouldClean) {
+    // Limpar pasta supabase/functions APÓS o backup apenas se o usuário escolheu
+    // Nota: shouldCleanAfter já foi definido acima
+    if (shouldCleanAfter) {
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.gray('   - supabase/functions limpo.'));
+      console.log(chalk.white('   - supabase/functions limpo após o backup.'));
+    } else {
+      // Preservar tudo: tanto as funções que já existiam quanto as que foram baixadas
+      // As funções baixadas não foram removidas individualmente (linha acima foi ajustada)
+      console.log(chalk.white('   - supabase/functions preservada conforme solicitado.'));
     }
     
     return { 

package/src/commands/backup/steps/09-supabase-temp.js

@@ -14,10 +14,10 @@ module.exports = async (context) => {
     
     const fileCount = await copyDirSafe(tempDir, backupTempDir);
     
-    console.log(chalk.gray(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
+    console.log(chalk.white(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
     
     if (fileCount === 0) {
-      console.log(chalk.gray('   - Nenhum arquivo encontrado em supabase/.temp'));
+      console.log(chalk.white('   - Nenhum arquivo encontrado em supabase/.temp'));
     } else {
       console.log(chalk.green(`   ✅ ${fileCount} arquivo(s) copiado(s)`));
     }
@@ -27,7 +27,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(tempDir);
-      console.log(chalk.gray('   - supabase/.temp apagado.'));
+      console.log(chalk.white('   - supabase/.temp apagado.'));
     }
     
     return {

package/src/commands/backup/steps/10-migrations.js

@@ -17,10 +17,10 @@ module.exports = async (context) => {
     // Limpar migrations local (opcional, mas recomendado para garantir servidor como fonte da verdade)
     const migrationsDir = path.join(process.cwd(), 'supabase', 'migrations');
     await cleanDir(migrationsDir);
-    console.log(chalk.gray('   - Limpando supabase/migrations...'));
+    console.log(chalk.white('   - Limpando supabase/migrations...'));
     
     // Baixar todas as migrations do servidor usando migration fetch
-    console.log(chalk.gray('   - Baixando todas as migrations do servidor usando migration fetch...'));
+    console.log(chalk.white('   - Baixando todas as migrations do servidor usando migration fetch...'));
     
     const env = {
       ...process.env,
@@ -43,12 +43,12 @@ module.exports = async (context) => {
     
     // Contar arquivos baixados
     const fileCount = await countFiles(migrationsDir);
-    console.log(chalk.gray(`   - Arquivos baixados: ${fileCount} migrations`));
+    console.log(chalk.white(`   - Arquivos baixados: ${fileCount} migrations`));
     
     // Copiar migrations para o backup
     const backupMigrationsDir = path.join(backupDir, 'migrations');
     const copiedCount = await copyDirSafe(migrationsDir, backupMigrationsDir);
-    console.log(chalk.gray(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
+    console.log(chalk.white(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
     
     if (copiedCount > 0) {
       console.log(chalk.green(`   ✅ ${copiedCount} migration(s) copiada(s)`));

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

@@ -13,8 +13,8 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
     
     // 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...'));
+      console.log(chalk.white('   - Arquivo .backup.gz detectado'));
+      console.log(chalk.white('   - Extraindo arquivo .gz...'));
       
       const unzipCmd = [
         'docker run --rm',
@@ -24,10 +24,10 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       
       execSync(unzipCmd, { stdio: 'pipe' });
       uncompressedFile = fileName.replace('.gz', '');
-      console.log(chalk.gray('   - Arquivo descompactado: ' + uncompressedFile));
+      console.log(chalk.white('   - 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'));
+      console.log(chalk.white('   - Arquivo .backup detectado (já descompactado)'));
+      console.log(chalk.white('   - Prosseguindo com restauração direta'));
     } else {
       throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
     }
@@ -49,8 +49,8 @@ module.exports = async ({ backupFilePath, 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.cyan('   - Executando psql via Docker...'));
+    console.log(chalk.cyan('   ℹ️ 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'));

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

@@ -32,7 +32,7 @@ module.exports = async ({ backupPath, targetProject }) => {
       return { success: false, functions_count: 0, success_count: 0 };
     }
     
-    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
+    console.log(chalk.white(`   - 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');
@@ -40,8 +40,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     // 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...'));
+    // Limpar supabase/functions antes de copiar (necessário para garantir ambiente limpo)
+    console.log(chalk.cyan('   - Limpando supabase/functions antes de copiar...'));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
@@ -54,13 +54,13 @@ module.exports = async ({ backupPath, targetProject }) => {
       const backupFuncPath = path.join(edgeFunctionsDir, funcName);
       const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
       
-      console.log(chalk.gray(`   - Copiando ${funcName} para supabase/functions...`));
+      console.log(chalk.white(`   - Copiando ${funcName} para supabase/functions...`));
       
       // Copiar recursivamente
       await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
     }
     
-    console.log(chalk.gray(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
+    console.log(chalk.white(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
     
     // Linkar com o projeto destino
     try {
@@ -77,7 +77,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     // Deploy das Edge Functions
     let successCount = 0;
     for (const funcName of functions) {
-      console.log(chalk.gray(`   - Deployando ${funcName}...`));
+      console.log(chalk.white(`   - Deployando ${funcName}...`));
       
       try {
         execSync(`supabase functions deploy ${funcName}`, {
@@ -95,8 +95,8 @@ module.exports = async ({ backupPath, targetProject }) => {
       }
     }
     
-    // Limpar supabase/functions após deploy
-    console.log(chalk.gray('   - Limpando supabase/functions após deploy...'));
+    // Limpar supabase/functions após deploy (arquivos temporários não são mais necessários)
+    console.log(chalk.cyan('   - Limpando supabase/functions após deploy...'));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
     } catch {

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

@@ -25,11 +25,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     if (authSettings.settings?.auth_url_config) {
       Object.entries(authSettings.settings.auth_url_config).forEach(([key, value]) => {
-        console.log(chalk.gray(`   - ${key}: ${value}`));
+        console.log(chalk.white(`   - ${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.white(`   - ${key}: ${value}`));
       });
     }
     

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

@@ -26,23 +26,23 @@ module.exports = async ({ backupPath }) => {
     const buckets = manifest?.components?.storage?.buckets || [];
     
     if (buckets.length === 0) {
-      console.log(chalk.gray('   ℹ️  Nenhum bucket para restaurar'));
+      console.log(chalk.white('   ℹ️  Nenhum bucket para restaurar'));
       return { success: false, buckets_count: 0 };
     }
     
     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'})`));
+      console.log(chalk.white(`   - ${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'));
+    console.log(chalk.white('\n   📋 Instruções:'));
+    console.log(chalk.white('   1. Execute o script no Google Colab'));
+    console.log(chalk.white('   2. Configure as credenciais dos projetos (origem e destino)'));
+    console.log(chalk.white('   3. Execute a migração'));
     
     await inquirer.prompt([{
       type: 'input',

package/src/commands/restore/steps/07-database-settings.js

@@ -22,11 +22,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     const extensions = dbSettings.extensions || [];
     
     if (extensions.length > 0) {
-      console.log(chalk.gray(`   - Habilitando ${extensions.length} extension(s)...`));
+      console.log(chalk.white(`   - Habilitando ${extensions.length} extension(s)...`));
       
       for (const ext of extensions) {
         const extName = typeof ext === 'string' ? ext : ext.name;
-        console.log(chalk.gray(`     - ${extName}`));
+        console.log(chalk.white(`     - ${extName}`));
         
         const sqlCommand = `CREATE EXTENSION IF NOT EXISTS ${extName};`;
         

package/src/commands/restore/steps/08-realtime-settings.js

@@ -25,9 +25,9 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     if (realtimeSettings.realtime_settings?.settings) {
       Object.values(realtimeSettings.realtime_settings.settings).forEach((setting) => {
-        console.log(chalk.gray(`   - ${setting.label}: ${setting.value}`));
+        console.log(chalk.white(`   - ${setting.label}: ${setting.value}`));
         if (setting.description) {
-          console.log(chalk.gray(`     ${setting.description}`));
+          console.log(chalk.white(`     ${setting.description}`));
         }
       });
     }

package/src/utils/supabaseLink.js

@@ -28,7 +28,7 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
   const tempDir = path.join(process.cwd(), 'supabase', '.temp');
   
   // Remover supabase/.temp completamente
-  console.log(chalk.gray(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
+  console.log(chalk.white(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
   
   try {
     await fs.rm(tempDir, { recursive: true, force: true });
@@ -66,7 +66,7 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
       );
     }
     
-    console.log(chalk.gray(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
+    console.log(chalk.white(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
   } catch (error) {
     if (error.message.includes('Validação falhou')) {
       throw error;