smoonb 0.0.46 → 0.0.48

package/package.json

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

package/src/commands/backup/index.js

@@ -0,0 +1,290 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { ensureDir, writeJson } = require('../../utils/fsx');
+const { readConfig, validateFor } = require('../../utils/config');
+const { showBetaBanner } = require('../../utils/banner');
+const { getDockerVersion } = require('../../utils/docker');
+const { readEnvFile, writeEnvFile, backupEnvFile } = require('../../utils/env');
+const { saveEnvMap } = require('../../utils/envMap');
+const { mapEnvVariablesInteractively, askComponentsFlags } = require('../../interactive/envMapper');
+
+// Importar todas as etapas
+const step00DockerValidation = require('./steps/00-docker-validation');
+const step01Database = require('./steps/01-database');
+const step02DatabaseSeparated = require('./steps/02-database-separated');
+const step03DatabaseSettings = require('./steps/03-database-settings');
+const step04AuthSettings = require('./steps/04-auth-settings');
+const step05RealtimeSettings = require('./steps/05-realtime-settings');
+const step06Storage = require('./steps/06-storage');
+const step07CustomRoles = require('./steps/07-custom-roles');
+const step08EdgeFunctions = require('./steps/08-edge-functions');
+const step09SupabaseTemp = require('./steps/09-supabase-temp');
+const step10Migrations = require('./steps/10-migrations');
+
+// Exportar FUNÇÃO em vez de objeto Command
+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 require('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);
+    }
+
+    // Carregar configuração existente apenas para defaults de diretório
+    const config = await readConfig().catch(() => ({ backup: { outputDir: './backups' }, supabase: {} }));
+    validateFor(config, 'backup');
+
+    // Pré-passo de ENV: criar diretório de backup com timestamp já no início
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hour = String(now.getHours()).padStart(2, '0');
+    const minute = String(now.getMinutes()).padStart(2, '0');
+    const second = String(now.getSeconds()).padStart(2, '0');
+
+    // Resolver diretório de saída
+    const defaultOutput = options.output || config.backup?.outputDir || './backups';
+    const backupDir = path.join(defaultOutput, `backup-${year}-${month}-${day}-${hour}-${minute}-${second}`);
+    await ensureDir(backupDir);
+
+    // Backup e mapeamento do .env.local
+    const envPath = path.join(process.cwd(), '.env.local');
+    const envBackupPath = path.join(backupDir, 'env', '.env.local');
+    await ensureDir(path.dirname(envBackupPath));
+    await backupEnvFile(envPath, envBackupPath);
+    console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+
+    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 currentEnv = await readEnvFile(envPath);
+    const { finalEnv, dePara } = await mapEnvVariablesInteractively(currentEnv, expectedKeys);
+    await writeEnvFile(envPath, finalEnv);
+    await saveEnvMap(dePara, path.join(backupDir, 'env', 'env-map.json'));
+    console.log(chalk.green('✅ .env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.'));
+
+    function getValue(expectedKey) {
+      const clientKey = Object.keys(dePara).find(k => dePara[k] === expectedKey);
+      return clientKey ? finalEnv[clientKey] : '';
+    }
+
+    // Recalcular outputDir a partir do ENV mapeado
+    const resolvedOutputDir = options.output || getValue('SMOONB_OUTPUT_DIR') || config.backup?.outputDir || './backups';
+
+    // Se mudou o outputDir, movemos o backupDir inicial para o novo local mantendo timestamp
+    const finalBackupDir = backupDir.startsWith(path.resolve(resolvedOutputDir))
+      ? backupDir
+      : path.join(resolvedOutputDir, path.basename(backupDir));
+    if (finalBackupDir !== backupDir) {
+      await ensureDir(resolvedOutputDir);
+      await fs.rename(backupDir, finalBackupDir);
+    }
+
+    const projectId = getValue('SUPABASE_PROJECT_ID');
+    const accessToken = getValue('SUPABASE_ACCESS_TOKEN');
+    const databaseUrl = getValue('SUPABASE_DB_URL');
+
+    if (!databaseUrl) {
+      console.log(chalk.red('❌ DATABASE_URL NÃO CONFIGURADA'));
+      console.log('');
+      console.log(chalk.yellow('📋 Para fazer backup completo do Supabase, você precisa:'));
+      console.log(chalk.yellow('   1. Configurar SUPABASE_DB_URL no .env.local'));
+      console.log(chalk.yellow('   2. Repetir o comando de backup'));
+      console.log('');
+      console.log(chalk.blue('💡 Exemplo de configuração:'));
+      console.log(chalk.gray('   "databaseUrl": "postgresql://postgres:[senha]@db.[projeto].supabase.co:5432/postgres"'));
+      console.log('');
+      console.log(chalk.red('🚫 Backup cancelado - Configuração incompleta'));
+      process.exit(1);
+    }
+
+    if (!accessToken) {
+      console.log(chalk.red('❌ ACCESS_TOKEN NÃO CONFIGURADO'));
+      console.log('');
+      console.log(chalk.yellow('📋 Para fazer backup completo do Supabase, você precisa:'));
+      console.log(chalk.yellow('   1. Obter Personal Access Token do Supabase'));
+      console.log(chalk.yellow('   2. Configurar SUPABASE_ACCESS_TOKEN no .env.local'));
+      console.log(chalk.yellow('   3. Repetir o comando de backup'));
+      console.log('');
+      console.log(chalk.blue('🔗 Como obter o token:'));
+      console.log(chalk.gray('   1. Acesse: https://supabase.com/dashboard/account/tokens'));
+      console.log(chalk.gray('   2. Clique: "Generate new token"'));
+      console.log(chalk.gray('   3. Copie o token (formato: sbp_...)'));
+      console.log('');
+      console.log(chalk.red('🚫 Backup cancelado - Token não configurado'));
+      process.exit(1);
+    }
+
+    console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${projectId}`));
+
+    // Executar validação Docker (etapa 0)
+    await step00DockerValidation();
+
+    // Flags de componentes
+    const flags = await askComponentsFlags();
+
+    // Criar contexto compartilhado para as etapas
+    const context = {
+      projectId,
+      accessToken,
+      databaseUrl,
+      backupDir: finalBackupDir,
+      outputDir: resolvedOutputDir,
+      options: { ...options, flags }
+    };
+
+    // Criar manifest
+    const manifest = {
+      created_at: new Date().toISOString(),
+      project_id: projectId,
+      smoonb_version: require('../../../package.json').version,
+      backup_type: 'pg_dumpall_docker_dashboard_compatible',
+      docker_version: await getDockerVersion(),
+      dashboard_compatible: true,
+      components: {}
+    };
+
+    // Executar todas as etapas na ordem
+    console.log(chalk.blue(`📁 Diretório: ${finalBackupDir}`));
+    console.log(chalk.gray(`🐳 Backup via Docker Desktop`));
+
+    // 1. Backup Database via pg_dumpall Docker
+    console.log(chalk.blue('\n📊 1/12 - Backup da Database PostgreSQL via pg_dumpall Docker...'));
+    const databaseResult = await step01Database(context);
+    manifest.components.database = databaseResult;
+
+    // 2. Backup Database Separado
+    console.log(chalk.blue('\n📊 2/12 - Backup da Database PostgreSQL (arquivos SQL separados)...'));
+    const dbSeparatedResult = await step02DatabaseSeparated(context);
+    manifest.components.database_separated = {
+      success: dbSeparatedResult.success,
+      method: 'supabase-cli',
+      files: dbSeparatedResult.files || [],
+      total_size_kb: dbSeparatedResult.totalSizeKB || '0.0'
+    };
+
+    // 3. Backup Database Settings
+    console.log(chalk.blue('\n🔧 3/12 - Backup das Database Extensions and Settings via SQL...'));
+    const databaseSettingsResult = await step03DatabaseSettings(context);
+    manifest.components.database_settings = databaseSettingsResult;
+
+    // 4. Backup Auth Settings
+    if (flags?.includeAuth) {
+      console.log(chalk.blue('\n🔐 4/12 - Backup das Auth Settings via API...'));
+      const authResult = await step04AuthSettings(context);
+      manifest.components.auth_settings = authResult;
+    }
+
+    // 5. Backup Realtime Settings
+    if (flags?.includeRealtime) {
+      console.log(chalk.blue('\n🔄 5/12 - Backup das Realtime Settings via Captura Interativa...'));
+      const realtimeResult = await step05RealtimeSettings(context);
+      manifest.components.realtime = realtimeResult;
+    }
+
+    // 6. Backup Storage
+    if (flags?.includeStorage) {
+      console.log(chalk.blue('\n📦 6/12 - Backup do Storage via API...'));
+      const storageResult = await step06Storage(context);
+      manifest.components.storage = storageResult;
+    }
+
+    // 7. Backup Custom Roles
+    console.log(chalk.blue('\n👥 7/12 - Backup dos Custom Roles via SQL...'));
+    const rolesResult = await step07CustomRoles(context);
+    manifest.components.custom_roles = rolesResult;
+
+    // 8. Backup Edge Functions
+    if (flags?.includeFunctions) {
+      console.log(chalk.blue('\n⚡ 8/12 - Backup das Edge Functions via Docker...'));
+      const functionsResult = await step08EdgeFunctions(context);
+      manifest.components.edge_functions = functionsResult;
+    }
+
+    // 9. Backup Supabase .temp
+    console.log(chalk.blue('\n📁 9/12 - Backup do Supabase .temp...'));
+    const supabaseTempResult = await step09SupabaseTemp(context);
+    manifest.components.supabase_temp = supabaseTempResult;
+
+    // 10. Backup Migrations
+    console.log(chalk.blue('\n📋 10/12 - Backup das Migrations...'));
+    const migrationsResult = await step10Migrations(context);
+    manifest.components.migrations = migrationsResult;
+
+    // Salvar manifest
+    await writeJson(path.join(finalBackupDir, 'backup-manifest.json'), manifest);
+
+    // Exibir resumo final
+    console.log(chalk.green('\n🎉 BACKUP COMPLETO FINALIZADO VIA DOCKER!'));
+    console.log(chalk.blue(`📁 Localização: ${finalBackupDir}`));
+    console.log(chalk.green(`📊 Database: ${databaseResult.fileName} (${databaseResult.size} KB) - Idêntico ao Dashboard`));
+    console.log(chalk.green(`📊 Database SQL: ${dbSeparatedResult.files?.length || 0} arquivos separados (${dbSeparatedResult.totalSizeKB} KB) - Para troubleshooting`));
+    console.log(chalk.green(`🔧 Database Settings: ${databaseSettingsResult.fileName} (${databaseSettingsResult.size} KB) - Extensions e Configurações`));
+    
+    if (flags?.includeFunctions && manifest.components.edge_functions) {
+      const functionsResult = manifest.components.edge_functions;
+      console.log(chalk.green(`⚡ Edge Functions: ${functionsResult.success_count || 0}/${functionsResult.functions_count || 0} functions baixadas via Docker`));
+    }
+    if (flags?.includeAuth && manifest.components.auth_settings) {
+      const authResult = manifest.components.auth_settings;
+      console.log(chalk.green(`🔐 Auth Settings: ${authResult.success ? 'Exportadas via API' : 'Falharam'}`));
+    }
+    if (flags?.includeStorage && manifest.components.storage) {
+      const storageResult = manifest.components.storage;
+      console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API`));
+    }
+    console.log(chalk.green(`👥 Custom Roles: ${rolesResult.roles?.length || 0} roles exportados via SQL`));
+    
+    // Determinar mensagem correta baseada no método usado
+    if (flags?.includeRealtime && manifest.components.realtime) {
+      const realtimeResult = manifest.components.realtime;
+      let realtimeMessage = 'Falharam';
+      if (realtimeResult.success) {
+        if (options.skipRealtime) {
+          realtimeMessage = 'Configurações copiadas do backup anterior';
+        } else {
+          realtimeMessage = 'Configurações capturadas interativamente';
+        }
+      }
+      console.log(chalk.green(`🔄 Realtime: ${realtimeMessage}`));
+    }
+
+    // report.json
+    await writeJson(path.join(finalBackupDir, 'report.json'), {
+      process: 'backup',
+      created_at: manifest.created_at,
+      project_id: manifest.project_id,
+      assets: {
+        env: path.join(finalBackupDir, 'env', '.env.local'),
+        env_map: path.join(finalBackupDir, 'env', 'env-map.json'),
+        manifest: path.join(finalBackupDir, 'backup-manifest.json')
+      },
+      components: {
+        includeFunctions: !!flags?.includeFunctions,
+        includeStorage: !!flags?.includeStorage,
+        includeAuth: !!flags?.includeAuth,
+        includeRealtime: !!flags?.includeRealtime
+      }
+    });
+
+    return { success: true, backupDir: finalBackupDir, manifest };
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro no backup: ${error.message}`));
+    process.exit(1);
+  }
+};
+

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

@@ -0,0 +1,24 @@
+const chalk = require('chalk');
+const { canPerformCompleteBackup } = require('../../../utils/docker');
+const { showDockerMessagesAndExit } = require('../utils');
+
+/**
+ * Etapa 0: Validação Docker
+ * Deve ocorrer antes de tudo
+ */
+module.exports = async () => {
+  console.log(chalk.blue('\n🐳 0/12 - Validação Docker...'));
+  console.log(chalk.gray('🔍 Verificando dependências Docker...'));
+  
+  const backupCapability = await canPerformCompleteBackup();
+
+  if (!backupCapability.canBackupComplete) {
+    showDockerMessagesAndExit(backupCapability.reason);
+  }
+  
+  console.log(chalk.green('✅ Docker Desktop detectado e funcionando'));
+  console.log(chalk.gray(`🐳 Versão: ${backupCapability.dockerStatus.version}`));
+  
+  return { success: true };
+};
+

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

@@ -0,0 +1,72 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+
+/**
+ * Etapa 1: Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
+ */
+module.exports = async ({ databaseUrl, backupDir }) => {
+  try {
+    console.log(chalk.gray('   - Criando backup completo via pg_dumpall...'));
+    
+    // Extrair credenciais da databaseUrl
+    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+    
+    if (!urlMatch) {
+      throw new Error('Database URL inválida');
+    }
+    
+    const [, username, password, host, port] = urlMatch;
+    
+    // Gerar nome do arquivo igual ao dashboard
+    const now = new Date();
+    const day = String(now.getDate()).padStart(2, '0');
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const year = now.getFullYear();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    
+    const fileName = `db_cluster-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.backup`;
+    
+    // Usar caminho absoluto igual às Edge Functions
+    const backupDirAbs = path.resolve(backupDir);
+    
+    // Comando pg_dumpall via Docker
+    const dockerCmd = [
+      'docker run --rm --network host',
+      `-v "${backupDirAbs}:/host"`,
+      `-e PGPASSWORD="${password}"`,
+      'postgres:17 pg_dumpall',
+      `-h ${host}`,
+      `-p ${port}`,
+      `-U ${username}`,
+      `-f /host/${fileName}`
+    ].join(' ');
+    
+    console.log(chalk.gray('   - Executando pg_dumpall via Docker...'));
+    execSync(dockerCmd, { stdio: 'pipe' });
+    
+    // Compactar igual ao Supabase Dashboard
+    const gzipCmd = [
+      'docker run --rm',
+      `-v "${backupDirAbs}:/host"`,
+      `postgres:17 gzip /host/${fileName}`
+    ].join(' ');
+    
+    execSync(gzipCmd, { stdio: 'pipe' });
+    
+    const finalFileName = `${fileName}.gz`;
+    const stats = await fs.stat(path.join(backupDir, finalFileName));
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    console.log(chalk.green(`     ✅ Database backup: ${finalFileName} (${sizeKB} KB)`));
+    
+    return { success: true, size: sizeKB, fileName: finalFileName };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro no backup do database: ${error.message}`));
+    return { success: false };
+  }
+};
+

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

@@ -0,0 +1,82 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+
+/**
+ * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
+ */
+module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
+  try {
+    console.log(chalk.gray('   - 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...'));
+    const schemaFile = path.join(backupDir, 'schema.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`, { 
+        stdio: 'pipe', 
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
+      });
+      const stats = await fs.stat(schemaFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'schema.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro no schema: ${error.message}`));
+    }
+    
+    // 2. Backup dos Dados
+    console.log(chalk.gray('   - Exportando dados...'));
+    const dataFile = path.join(backupDir, 'data.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`, { 
+        stdio: 'pipe', 
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
+      });
+      const stats = await fs.stat(dataFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'data.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro nos dados: ${error.message}`));
+    }
+    
+    // 3. Backup dos Roles
+    console.log(chalk.gray('   - Exportando roles...'));
+    const rolesFile = path.join(backupDir, 'roles.sql');
+    
+    try {
+      execSync(`supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`, { 
+        stdio: 'pipe', 
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
+      });
+      const stats = await fs.stat(rolesFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      files.push({ filename: 'roles.sql', sizeKB });
+      totalSizeKB += parseFloat(sizeKB);
+      console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro nos roles: ${error.message}`));
+    }
+    
+    return { 
+      success: files.length > 0, 
+      files, 
+      totalSizeKB: totalSizeKB.toFixed(1) 
+    };
+    
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro nos backups SQL separados: ${error.message}`));
+    return { success: false, files: [], totalSizeKB: '0.0' };
+  }
+};
+

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

@@ -0,0 +1,178 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+
+/**
+ * Etapa 3: Backup Database Extensions and Settings via SQL
+ */
+module.exports = async ({ databaseUrl, projectId, backupDir }) => {
+  try {
+    console.log(chalk.gray('   - Capturando Database Extensions and Settings...'));
+    
+    // Extrair credenciais da databaseUrl
+    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+    
+    if (!urlMatch) {
+      throw new Error('Database URL inválida');
+    }
+    
+    const [, username, password, host, port, database] = urlMatch;
+    
+    // Gerar nome do arquivo
+    const now = new Date();
+    const day = String(now.getDate()).padStart(2, '0');
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const year = now.getFullYear();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    
+    const fileName = `database-settings-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.json`;
+    
+    // Usar caminho absoluto igual às outras funções
+    const backupDirAbs = path.resolve(backupDir);
+    
+    // Script SQL para capturar todas as configurações
+    const sqlScript = `
+-- Database Extensions and Settings Backup
+-- Generated at: ${new Date().toISOString()}
+
+-- 1. Capturar extensões instaladas
+SELECT json_agg(
+  json_build_object(
+    'name', extname,
+    'version', extversion,
+    'schema', extnamespace::regnamespace
+  )
+) as extensions
+FROM pg_extension;
+
+-- 2. Capturar configurações PostgreSQL importantes
+SELECT json_agg(
+  json_build_object(
+    'name', name,
+    'setting', setting,
+    'unit', unit,
+    'context', context,
+    'description', short_desc
+  )
+) as postgres_settings
+FROM pg_settings 
+WHERE name IN (
+  'statement_timeout',
+  'idle_in_transaction_session_timeout', 
+  'lock_timeout',
+  'shared_buffers',
+  'work_mem',
+  'maintenance_work_mem',
+  'effective_cache_size',
+  'max_connections',
+  'log_statement',
+  'log_min_duration_statement',
+  'timezone',
+  'log_timezone', 
+  'default_transaction_isolation',
+  'default_transaction_read_only',
+  'checkpoint_completion_target',
+  'wal_buffers',
+  'max_wal_size',
+  'min_wal_size'
+);
+
+-- 3. Capturar configurações específicas dos roles Supabase
+SELECT json_agg(
+  json_build_object(
+    'role', rolname,
+    'config', rolconfig
+  )
+) as role_configurations
+FROM pg_roles 
+WHERE rolname IN ('anon', 'authenticated', 'authenticator', 'postgres', 'service_role')
+AND rolconfig IS NOT NULL;
+
+-- 4. Capturar configurações de PGAudit (se existir)
+SELECT json_agg(
+  json_build_object(
+    'role', rolname,
+    'config', rolconfig
+  )
+) as pgaudit_configurations
+FROM pg_roles 
+WHERE rolconfig IS NOT NULL 
+AND EXISTS (
+  SELECT 1 FROM unnest(rolconfig) AS config 
+  WHERE config LIKE '%pgaudit%'
+);
+`;
+
+    // Salvar script SQL temporário
+    const sqlFile = path.join(backupDir, 'temp_settings.sql');
+    await fs.writeFile(sqlFile, sqlScript);
+    
+    // Executar via Docker
+    const dockerCmd = [
+      'docker run --rm --network host',
+      `-v "${backupDirAbs}:/host"`,
+      `-e PGPASSWORD="${password}"`,
+      'postgres:17 psql',
+      `-h ${host}`,
+      `-p ${port}`,
+      `-U ${username}`,
+      `-d ${database}`,
+      '-f /host/temp_settings.sql',
+      '-t', // Tuples only
+      '-A'  // Unaligned output
+    ].join(' ');
+    
+    console.log(chalk.gray('   - Executando queries de configurações via Docker...'));
+    const output = execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
+    
+    // Processar output e criar JSON estruturado
+    const lines = output.trim().split('\n').filter(line => line.trim());
+    
+    const result = {
+      database_settings: {
+        note: "Configurações específicas do database Supabase capturadas via SQL",
+        captured_at: new Date().toISOString(),
+        project_id: projectId,
+        extensions: lines[0] ? JSON.parse(lines[0]) : [],
+        postgres_settings: lines[1] ? JSON.parse(lines[1]) : [],
+        role_configurations: lines[2] ? JSON.parse(lines[2]) : [],
+        pgaudit_configurations: lines[3] ? JSON.parse(lines[3]) : [],
+        restore_instructions: {
+          note: "Estas configurações precisam ser aplicadas manualmente após a restauração do database",
+          steps: [
+            "1. Restaurar o database usando o arquivo .backup.gz",
+            "2. Aplicar configurações de Postgres via SQL:",
+            "   ALTER DATABASE postgres SET setting_name TO 'value';",
+            "3. Aplicar configurações de roles via SQL:",
+            "   ALTER ROLE role_name SET setting_name TO 'value';",
+            "4. Habilitar extensões necessárias via Dashboard ou SQL:",
+            "   CREATE EXTENSION IF NOT EXISTS extension_name;",
+            "5. Verificar configurações aplicadas:",
+            "   SELECT name, setting FROM pg_settings WHERE name IN (...);"
+          ]
+        }
+      }
+    };
+    
+    // Salvar arquivo JSON
+    const jsonFile = path.join(backupDir, fileName);
+    await fs.writeFile(jsonFile, JSON.stringify(result, null, 2));
+    
+    // Limpar arquivo temporário
+    await fs.unlink(sqlFile);
+    
+    const stats = await fs.stat(jsonFile);
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    console.log(chalk.green(`     ✅ Database Settings: ${fileName} (${sizeKB} KB)`));
+    
+    return { success: true, size: sizeKB, fileName: fileName };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro no backup das Database Settings: ${error.message}`));
+    return { success: false };
+  }
+};
+