smoonb 0.0.47 → 0.0.49

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

@@ -0,0 +1,43 @@
+const chalk = require('chalk');
+const path = require('path');
+const { writeJson } = require('../../../utils/fsx');
+
+/**
+ * Etapa 4: Backup Auth Settings via Management API
+ */
+module.exports = async ({ projectId, accessToken, backupDir }) => {
+  try {
+    console.log(chalk.gray('   - 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`, {
+      headers: { 
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    if (!authResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao obter Auth Settings: ${authResponse.status} ${authResponse.statusText}`));
+      return { success: false };
+    }
+
+    const authSettings = await authResponse.json();
+    
+    // Salvar configurações de Auth
+    const authSettingsPath = path.join(backupDir, 'auth-settings.json');
+    await writeJson(authSettingsPath, {
+      project_id: projectId,
+      timestamp: new Date().toISOString(),
+      settings: authSettings
+    });
+
+    console.log(chalk.green(`✅ Auth Settings exportadas: ${path.basename(authSettingsPath)}`));
+    return { success: true };
+
+  } catch (error) {
+    console.log(chalk.yellow(`   ⚠️ Erro no backup das Auth Settings: ${error.message}`));
+    return { success: false };
+  }
+};
+

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

@@ -0,0 +1,26 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { captureRealtimeSettings } = require('../../../utils/realtime-settings');
+
+/**
+ * Etapa 5: Backup Realtime Settings via Captura Interativa
+ */
+module.exports = async ({ projectId, backupDir, options }) => {
+  try {
+    console.log(chalk.gray('   - Capturando Realtime Settings interativamente...'));
+    
+    const result = await captureRealtimeSettings(projectId, backupDir, options?.skipRealtime);
+    
+    const stats = await fs.stat(path.join(backupDir, 'realtime-settings.json'));
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    console.log(chalk.green(`     ✅ Realtime Settings capturadas: ${sizeKB} KB`));
+    
+    return { success: true, settings: result };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro ao capturar Realtime Settings: ${error.message}`));
+    return { success: false };
+  }
+};
+

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

@@ -0,0 +1,90 @@
+const chalk = require('chalk');
+const path = require('path');
+const { ensureDir, writeJson } = require('../../../utils/fsx');
+
+/**
+ * Etapa 6: Backup Storage via Supabase API
+ */
+module.exports = async ({ projectId, accessToken, backupDir }) => {
+  try {
+    const storageDir = path.join(backupDir, 'storage');
+    await ensureDir(storageDir);
+
+    console.log(chalk.gray('   - 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`, {
+      headers: { 
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    if (!storageResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${storageResponse.status} ${storageResponse.statusText}`));
+      return { success: false, buckets: [] };
+    }
+
+    const buckets = await storageResponse.json();
+
+    if (!buckets || buckets.length === 0) {
+      console.log(chalk.gray('   - 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`));
+
+    const processedBuckets = [];
+
+    for (const bucket of buckets || []) {
+      try {
+        console.log(chalk.gray(`   - 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`, {
+          headers: { 
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          }
+        });
+
+        let objects = [];
+        if (objectsResponse.ok) {
+          objects = await objectsResponse.json();
+        }
+
+        const bucketInfo = {
+          id: bucket.id,
+          name: bucket.name,
+          public: bucket.public,
+          file_size_limit: bucket.file_size_limit,
+          allowed_mime_types: bucket.allowed_mime_types,
+          objects: objects || []
+        };
+
+        // Salvar informações do bucket
+        const bucketPath = path.join(storageDir, `${bucket.name}.json`);
+        await writeJson(bucketPath, bucketInfo);
+
+        processedBuckets.push({
+          name: bucket.name,
+          objectCount: objects?.length || 0
+        });
+
+        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${objects?.length || 0} objetos`));
+      } catch (error) {
+        console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
+      }
+    }
+
+    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets`));
+    return { success: true, buckets: processedBuckets };
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
+    return { success: false, buckets: [] };
+  }
+};
+

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

@@ -0,0 +1,39 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { promisify } = require('util');
+const { exec } = require('child_process');
+
+const execAsync = promisify(exec);
+
+/**
+ * Etapa 7: Backup Custom Roles via SQL
+ */
+module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
+  try {
+    console.log(chalk.gray('   - Exportando Custom Roles via Docker...'));
+    
+    const customRolesFile = path.join(backupDir, 'custom-roles.sql');
+    
+    try {
+      // Usar Supabase CLI via Docker para roles
+      await execAsync(`supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`, { 
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
+      });
+      
+      const stats = await fs.stat(customRolesFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      
+      console.log(chalk.green(`     ✅ Custom Roles exportados via Docker: ${sizeKB} KB`));
+      
+      return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles via Docker: ${error.message}`));
+      return { success: false, roles: [] };
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro no backup dos Custom Roles: ${error.message}`));
+    return { success: false, roles: [] };
+  }
+};
+

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

@@ -0,0 +1,153 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { ensureDir, writeJson } = require('../../../utils/fsx');
+const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
+const { cleanDir } = require('../../../utils/fsExtra');
+
+/**
+ * Etapa 8: Backup Edge Functions via Docker (reset link + limpeza opcional)
+ */
+module.exports = async (context) => {
+  const { projectId, accessToken, databaseUrl, backupDir } = context;
+  try {
+    const functionsDir = path.join(backupDir, 'edge-functions');
+    await ensureDir(functionsDir);
+
+    // Reset de link ao projeto de ORIGEM
+    const dbPassword = extractPasswordFromDbUrl(databaseUrl);
+    await ensureCleanLink(projectId, accessToken, dbPassword);
+
+    // Limpar pasta supabase/functions antes do backup
+    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
+    await cleanDir(supabaseFunctionsDir);
+    console.log(chalk.gray('   - Pasta supabase/functions limpa.'));
+
+    console.log(chalk.gray('   - 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`, {
+      headers: { 
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    if (!functionsResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${functionsResponse.status} ${functionsResponse.statusText}`));
+      return { success: false, reason: 'api_error', functions: [] };
+    }
+
+    const functions = await functionsResponse.json();
+    
+    if (!functions || functions.length === 0) {
+      console.log(chalk.gray('   - 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)`));
+    
+    const downloadedFunctions = [];
+    let successCount = 0;
+    let errorCount = 0;
+
+    // Baixar cada Edge Function via Supabase CLI
+    // 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}...`));
+        
+        // Criar diretório da função NO BACKUP
+        const functionTargetDir = path.join(functionsDir, func.name);
+        await ensureDir(functionTargetDir);
+        
+        // Diretório temporário onde o supabase CLI irá baixar (supabase/functions)
+        const tempDownloadDir = path.join(process.cwd(), 'supabase', 'functions', func.name);
+        
+        // Baixar Edge Function via Supabase CLI (sempre vai para supabase/functions)
+        const { execSync } = require('child_process');
+        
+        execSync(`supabase functions download ${func.name}`, {
+          timeout: 60000,
+          stdio: 'pipe'
+        });
+        
+        // COPIAR arquivos de supabase/functions para o backup
+        try {
+          const stat = await fs.stat(tempDownloadDir);
+          if (stat.isDirectory()) {
+            const files = await fs.readdir(tempDownloadDir);
+            for (const file of files) {
+              const srcPath = path.join(tempDownloadDir, file);
+              const dstPath = path.join(functionTargetDir, file);
+              
+              const fileStats = await fs.stat(srcPath);
+              if (fileStats.isDirectory()) {
+                // Copiar diretórios recursivamente
+                await fs.cp(srcPath, dstPath, { recursive: true });
+              } else {
+                // Copiar arquivos
+                await fs.copyFile(srcPath, dstPath);
+              }
+            }
+          }
+        } catch {
+          // Arquivos não foram baixados, continuar
+          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
+        }
+        
+        console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
+        successCount++;
+        
+        downloadedFunctions.push({
+          name: func.name,
+          slug: func.name,
+          version: func.version || 'unknown',
+          files: await fs.readdir(functionTargetDir).catch(() => [])
+        });
+        
+      } catch (error) {
+        console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${error.message}`));
+        errorCount++;
+      }
+    }
+    
+    console.log(chalk.green(`📊 Backup de Edge Functions concluído:`));
+    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) {
+      await cleanDir(supabaseFunctionsDir);
+      console.log(chalk.gray('   - supabase/functions limpo.'));
+    }
+    
+    return { 
+      success: true, 
+      reason: 'success',
+      functions: downloadedFunctions,
+      functions_count: functions.length,
+      success_count: successCount,
+      error_count: errorCount,
+      method: 'docker'
+    };
+
+  } catch (error) {
+    console.log(chalk.yellow(`   ⚠️ Erro durante backup de Edge Functions: ${error.message}`));
+    console.log('⏭️  Continuando com outros componentes...');
+    return { success: false, reason: 'download_error', error: error.message, functions: [] };
+  }
+};
+

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

@@ -0,0 +1,42 @@
+const chalk = require('chalk');
+const path = require('path');
+const { copyDirSafe } = require('../../../utils/fsExtra');
+const { cleanDir } = require('../../../utils/fsExtra');
+
+/**
+ * Etapa 9: Backup Supabase .temp (NOVA ETAPA INDEPENDENTE)
+ */
+module.exports = async (context) => {
+  const { backupDir } = context;
+  try {
+    const tempDir = path.join(process.cwd(), 'supabase', '.temp');
+    const backupTempDir = path.join(backupDir, 'supabase-temp');
+    
+    const fileCount = await copyDirSafe(tempDir, backupTempDir);
+    
+    console.log(chalk.gray(`   - 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'));
+    } else {
+      console.log(chalk.green(`   ✅ ${fileCount} arquivo(s) copiado(s)`));
+    }
+    
+    // Usar flag de limpeza do contexto (já foi perguntado no início)
+    const shouldClean = context?.cleanupFlags?.cleanTemp || false;
+    
+    if (shouldClean) {
+      await cleanDir(tempDir);
+      console.log(chalk.gray('   - supabase/.temp apagado.'));
+    }
+    
+    return {
+      success: true,
+      file_count: fileCount
+    };
+  } catch (error) {
+    console.log(chalk.yellow(`   ⚠️ Erro no backup do supabase/.temp: ${error.message}`));
+    return { success: false };
+  }
+};
+

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

@@ -0,0 +1,74 @@
+const chalk = require('chalk');
+const path = require('path');
+const { execSync } = require('child_process');
+const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
+const { cleanDir, countFiles, copyDirSafe } = require('../../../utils/fsExtra');
+
+/**
+ * Etapa 10: Backup Migrations (NOVA ETAPA INDEPENDENTE)
+ */
+module.exports = async (context) => {
+  const { projectId, accessToken, databaseUrl, backupDir } = context;
+  try {
+    // Reset de link ao projeto de ORIGEM
+    const dbPassword = extractPasswordFromDbUrl(databaseUrl);
+    await ensureCleanLink(projectId, accessToken, dbPassword);
+    
+    // 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...'));
+    
+    // Baixar todas as migrations do servidor usando migration fetch
+    console.log(chalk.gray('   - Baixando todas as migrations do servidor usando migration fetch...'));
+    
+    const env = {
+      ...process.env,
+      SUPABASE_ACCESS_TOKEN: accessToken
+    };
+    
+    try {
+      execSync('supabase migration fetch', {
+        cwd: process.cwd(),
+        stdio: 'pipe',
+        encoding: 'utf8',
+        timeout: 120000,
+        env
+      });
+    } catch (error) {
+      console.log(chalk.yellow(`   ⚠️ Erro ao executar migration fetch: ${error.message}`));
+      console.log(chalk.yellow('   💡 Verifique se o projeto está linkado corretamente e se o token está válido.'));
+      return { success: false };
+    }
+    
+    // Contar arquivos baixados
+    const fileCount = await countFiles(migrationsDir);
+    console.log(chalk.gray(`   - 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)...`));
+    
+    if (copiedCount > 0) {
+      console.log(chalk.green(`   ✅ ${copiedCount} migration(s) copiada(s)`));
+    }
+    
+    // Usar flag de limpeza do contexto (já foi perguntado no início)
+    const shouldClean = context?.cleanupFlags?.cleanMigrations || false;
+    
+    if (shouldClean) {
+      await cleanDir(migrationsDir);
+      console.log(chalk.gray('   - supabase/migrations apagado.'));
+    }
+    
+    return {
+      success: true,
+      file_count: copiedCount
+    };
+  } catch (error) {
+    console.log(chalk.yellow(`   ⚠️ Erro no backup das migrations: ${error.message}`));
+    return { success: false };
+  }
+};
+

package/src/commands/backup/utils.js

@@ -0,0 +1,69 @@
+const chalk = require('chalk');
+
+/**
+ * Função para mostrar mensagens educativas e encerrar elegantemente
+ */
+function showDockerMessagesAndExit(reason) {
+  console.log('');
+  
+  switch (reason) {
+    case 'docker_not_installed':
+      console.log(chalk.red('❌ DOCKER DESKTOP NÃO ENCONTRADO'));
+      console.log('');
+      console.log(chalk.yellow('📋 Para fazer backup completo do Supabase, você precisa:'));
+      console.log(chalk.yellow('   1. Instalar Docker Desktop'));
+      console.log(chalk.yellow('   2. Executar Docker Desktop'));
+      console.log(chalk.yellow('   3. Repetir o comando de backup'));
+      console.log('');
+      console.log(chalk.blue('🔗 Download: https://docs.docker.com/desktop/install/'));
+      console.log('');
+      console.log(chalk.gray('💡 O Docker Desktop é obrigatório para backup completo do Supabase'));
+      console.log(chalk.gray('   - Database PostgreSQL'));
+      console.log(chalk.gray('   - Edge Functions'));
+      console.log(chalk.gray('   - Todos os componentes via Supabase CLI'));
+      break;
+
+    case 'docker_not_running':
+      console.log(chalk.red('❌ DOCKER DESKTOP NÃO ESTÁ EXECUTANDO'));
+      console.log('');
+      console.log(chalk.yellow('📋 Para fazer backup completo do Supabase, você precisa:'));
+      console.log(chalk.yellow('   1. Abrir Docker Desktop'));
+      console.log(chalk.yellow('   2. Aguardar inicialização completa'));
+      console.log(chalk.yellow('   3. Repetir o comando de backup'));
+      console.log('');
+      console.log(chalk.blue('💡 Dica: Docker Desktop deve estar rodando em segundo plano'));
+      console.log('');
+      console.log(chalk.gray('💡 O Docker Desktop é obrigatório para backup completo do Supabase'));
+      console.log(chalk.gray('   - Database PostgreSQL'));
+      console.log(chalk.gray('   - Edge Functions'));
+      console.log(chalk.gray('   - Todos os componentes via Supabase CLI'));
+      break;
+
+    case 'supabase_cli_not_found':
+      console.log(chalk.red('❌ SUPABASE CLI NÃO ENCONTRADO'));
+      console.log('');
+      console.log(chalk.yellow('📋 Para fazer backup completo do Supabase, você precisa:'));
+      console.log(chalk.yellow('   1. Instalar Supabase CLI'));
+      console.log(chalk.yellow('   2. Repetir o comando de backup'));
+      console.log('');
+      console.log(chalk.blue('🔗 Instalação: npm install -g supabase'));
+      console.log('');
+      console.log(chalk.gray('💡 O Supabase CLI é obrigatório para backup completo do Supabase'));
+      console.log(chalk.gray('   - Database PostgreSQL'));
+      console.log(chalk.gray('   - Edge Functions'));
+      console.log(chalk.gray('   - Todos os componentes via Docker'));
+      break;
+  }
+
+  console.log('');
+  console.log(chalk.red('🚫 Backup cancelado - Pré-requisitos não atendidos'));
+  console.log(chalk.gray('   Instale os componentes necessários e tente novamente'));
+  console.log('');
+  
+  process.exit(1);
+}
+
+module.exports = {
+  showDockerMessagesAndExit
+};
+

package/src/commands/check.js

@@ -1,6 +1,5 @@
 const chalk = require('chalk');
 const path = require('path');
-const fs = require('fs');
 const { ensureBin, runCommand } = require('../utils/cli');
 const { readConfig, validateFor } = require('../utils/config');
 const { writeJson } = require('../utils/fsx');

package/src/commands/config.js

@@ -1,7 +1,6 @@
 const chalk = require('chalk');
 const fs = require('fs').promises;
 const path = require('path');
-const os = require('os');
 const { showBetaBanner } = require('../utils/banner');
 
 // Exportar FUNÇÃO em vez de objeto Command

package/src/commands/functions.js

@@ -4,7 +4,7 @@ const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
 
 // Exportar FUNÇÃO em vez de objeto Command
-module.exports = async (options) => {
+module.exports = async (_options) => {
   showBetaBanner();
   
   try {