smoonb 0.0.8 → 0.0.10

package/README.md

@@ -107,16 +107,18 @@ backups/backup-2024-01-15T10-30-45-123Z/
     └── [código das Edge Functions locais]
 ```
 
-### Restauração
+### Restauração Interativa
 ```bash
-npx smoonb restore --backup-dir backups/backup-2024-01-15T10-30-45-123Z
+npx smoonb restore
 ```
 
-**Processo:**
-1. Verifica se database está vazia (clean restore)
-2. Executa `roles.sql` (roles e permissões)
-3. Executa `schema.sql` (estrutura das tabelas)
-4. Executa `data.sql` (dados com COPY)
+**Processo interativo:**
+1. Lista todos os backups disponíveis
+2. Permite seleção numerada do backup desejado
+3. Verifica se database está vazia (clean restore)
+4. Executa `roles.sql` (roles e permissões)
+5. Executa `schema.sql` (estrutura das tabelas)
+6. Executa `data.sql` (dados com COPY)
 
 ### Verificação Pós-Restore
 ```bash
@@ -145,7 +147,7 @@ npx smoonb functions push
 | Comando | Descrição |
 |---------|-----------|
 | `npx smoonb backup` | Backup completo usando Supabase CLI |
-| `npx smoonb restore` | Restauração usando psql |
+| `npx smoonb restore` | Restauração interativa usando psql |
 | `npx smoonb check` | Verificação de integridade |
 | `npx smoonb functions` | Gerenciar Edge Functions |
 | `npx smoonb config` | Configurar credenciais |
@@ -179,8 +181,8 @@ npx smoonb backup
 # 3. Configurar .smoonbrc com credenciais do novo projeto
 npx smoonb config --init
 
-# 4. Restaurar backup
-npx smoonb restore --backup-dir backups/backup-YYYY-MM-DDTHH-MM-SS-sssZ
+# 4. Restaurar backup (modo interativo)
+npx smoonb restore
 
 # 5. Verificar integridade
 npx smoonb check

package/bin/smoonb.js

@@ -74,8 +74,7 @@ program
 
 program
   .command('restore')
-  .description('Restaurar backup completo usando psql')
-  .option('-b, --backup-dir <dir>', 'Diretório do backup a ser restaurado')
+  .description('Restaurar backup completo usando psql (modo interativo)')
   .option('--db-url <url>', 'URL da database de destino (override)')
   .action(commands.restore);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "main": "index.js",
   "bin": {
@@ -26,10 +26,10 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
-    "commander": "^11.1.0",
     "@supabase/supabase-js": "^2.38.0",
     "chalk": "^4.1.2",
-    "inquirer": "^8.2.6"
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.7"
   },
   "type": "commonjs",
   "repository": {

package/src/commands/backup.js

@@ -1,4 +1,3 @@
-const { Command } = require('commander');
 const chalk = require('chalk');
 const path = require('path');
 const { ensureBin, runCommand } = require('../utils/cli');
@@ -8,68 +7,66 @@ const { readConfig, validateFor } = require('../utils/config');
 const { IntrospectionService } = require('../services/introspect');
 const { showBetaBanner } = require('../index');
 
-const backupCommand = new Command('backup')
-  .description('Backup completo do projeto Supabase usando Supabase CLI')
-  .option('-o, --output <dir>', 'Diretório de saída')
-  .action(async (options) => {
-    showBetaBanner();
-    
-    try {
-      // Verificar se Supabase CLI está disponível
-      const supabasePath = await ensureBin('supabase');
-      if (!supabasePath) {
-        console.error(chalk.red('❌ Supabase CLI não encontrado'));
-        console.log(chalk.yellow('💡 Instale o Supabase CLI:'));
-        console.log(chalk.yellow('  npm install -g supabase'));
-        console.log(chalk.yellow('  ou visite: https://supabase.com/docs/guides/cli'));
-        process.exit(1);
-      }
-
-      // Carregar e validar configuração
-      const config = await readConfig();
-      validateFor(config, 'backup');
-
-      const databaseUrl = config.supabase.databaseUrl;
-      if (!databaseUrl) {
-        console.error(chalk.red('❌ databaseUrl não configurada'));
-        console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc'));
-        process.exit(1);
-      }
-
-      // Resolver diretório de saída
-      const outputDir = options.output || config.backup.outputDir;
-      
-      // Criar diretório de backup com timestamp
-      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const backupDir = path.join(outputDir, `backup-${timestamp}`);
-      await ensureDir(backupDir);
-
-      console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${config.supabase.projectId}`));
-      console.log(chalk.blue(`📁 Diretório: ${backupDir}`));
-
-      // 1. Backup da Database usando Supabase CLI
-      console.log(chalk.blue('\n📊 1/3 - Backup da Database PostgreSQL...'));
-      await backupDatabaseWithSupabaseCLI(databaseUrl, backupDir);
-
-      // 2. Gerar inventário real
-      console.log(chalk.blue('\n🔍 2/3 - Gerando inventário completo...'));
-      await generateInventory(config, backupDir);
-
-      // 3. Backup das Edge Functions locais
-      console.log(chalk.blue('\n⚡ 3/3 - Backup das Edge Functions locais...'));
-      await backupLocalFunctions(backupDir);
-
-      // Gerar manifesto do backup
-      await generateBackupManifest(config, backupDir);
-
-      console.log(chalk.green('\n🎉 Backup completo finalizado!'));
-      console.log(chalk.blue(`📁 Localização: ${backupDir}`));
-
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro no backup: ${error.message}`));
+// Exportar FUNÇÃO em vez de objeto Command
+module.exports = async (options) => {
+  showBetaBanner();
+  
+  try {
+    // Verificar se Supabase CLI está disponível
+    const supabasePath = await ensureBin('supabase');
+    if (!supabasePath) {
+      console.error(chalk.red('❌ Supabase CLI não encontrado'));
+      console.log(chalk.yellow('💡 Instale o Supabase CLI:'));
+      console.log(chalk.yellow('  npm install -g supabase'));
+      console.log(chalk.yellow('  ou visite: https://supabase.com/docs/guides/cli'));
+      process.exit(1);
+    }
+
+    // Carregar e validar configuração
+    const config = await readConfig();
+    validateFor(config, 'backup');
+
+    const databaseUrl = config.supabase.databaseUrl;
+    if (!databaseUrl) {
+      console.error(chalk.red('❌ databaseUrl não configurada'));
+      console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc'));
       process.exit(1);
     }
-  });
+
+    // Resolver diretório de saída
+    const outputDir = options.output || config.backup.outputDir;
+    
+    // Criar diretório de backup com timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(outputDir, `backup-${timestamp}`);
+    await ensureDir(backupDir);
+
+    console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${config.supabase.projectId}`));
+    console.log(chalk.blue(`📁 Diretório: ${backupDir}`));
+
+    // 1. Backup da Database usando Supabase CLI
+    console.log(chalk.blue('\n📊 1/3 - Backup da Database PostgreSQL...'));
+    await backupDatabaseWithSupabaseCLI(databaseUrl, backupDir);
+
+    // 2. Gerar inventário real
+    console.log(chalk.blue('\n🔍 2/3 - Gerando inventário completo...'));
+    await generateInventory(config, backupDir);
+
+    // 3. Backup das Edge Functions locais
+    console.log(chalk.blue('\n⚡ 3/3 - Backup das Edge Functions locais...'));
+    await backupLocalFunctions(backupDir);
+
+    // Gerar manifesto do backup
+    await generateBackupManifest(config, backupDir);
+
+    console.log(chalk.green('\n🎉 Backup completo finalizado!'));
+    console.log(chalk.blue(`📁 Localização: ${backupDir}`));
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro no backup: ${error.message}`));
+    process.exit(1);
+  }
+};
 
 // Backup da database usando Supabase CLI
 async function backupDatabaseWithSupabaseCLI(databaseUrl, backupDir) {
@@ -172,6 +169,4 @@ async function generateBackupManifest(config, backupDir) {
 
   const manifestPath = path.join(backupDir, 'backup-manifest.json');
   await writeJson(manifestPath, manifest);
-}
-
-module.exports = backupCommand;
+}

package/src/commands/check.js

@@ -1,59 +1,57 @@
-const { Command } = require('commander');
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
 const { ensureBin, runCommand } = require('../utils/cli');
-const { readConfig, validateFor, writeJson } = require('../utils/config');
+const { readConfig, validateFor } = require('../utils/config');
+const { writeJson } = require('../utils/fsx');
 const { IntrospectionService } = require('../services/introspect');
 const { showBetaBanner } = require('../index');
 
-const checkCommand = new Command('check')
-  .description('Verificar integridade do projeto Supabase após restauração')
-  .option('-o, --output <file>', 'Arquivo de saída do relatório', 'check-report.json')
-  .action(async (options) => {
-    showBetaBanner();
-    
-    try {
-      // Verificar se psql está disponível
-      const psqlPath = await ensureBin('psql');
-      if (!psqlPath) {
-        console.error(chalk.red('❌ psql não encontrado'));
-        console.log(chalk.yellow('💡 Instale PostgreSQL:'));
-        console.log(chalk.yellow('  https://www.postgresql.org/download/'));
-        process.exit(1);
-      }
+// Exportar FUNÇÃO em vez de objeto Command
+module.exports = async (options) => {
+  showBetaBanner();
+  
+  try {
+    // Verificar se psql está disponível
+    const psqlPath = await ensureBin('psql');
+    if (!psqlPath) {
+      console.error(chalk.red('❌ psql não encontrado'));
+      console.log(chalk.yellow('💡 Instale PostgreSQL:'));
+      console.log(chalk.yellow('  https://www.postgresql.org/download/'));
+      process.exit(1);
+    }
 
-      // Carregar configuração
-      const config = await readConfig();
-      validateFor(config, 'backup'); // Usar mesma validação do backup
+    // Carregar configuração
+    const config = await readConfig();
+    validateFor(config, 'backup'); // Usar mesma validação do backup
 
-      const databaseUrl = config.supabase.databaseUrl;
-      if (!databaseUrl) {
-        console.error(chalk.red('❌ databaseUrl não configurada'));
-        console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc'));
-        process.exit(1);
-      }
+    const databaseUrl = config.supabase.databaseUrl;
+    if (!databaseUrl) {
+      console.error(chalk.red('❌ databaseUrl não configurada'));
+      console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc'));
+      process.exit(1);
+    }
 
-      console.log(chalk.blue(`🔍 Verificando integridade do projeto: ${config.supabase.projectId}`));
+    console.log(chalk.blue(`🔍 Verificando integridade do projeto: ${config.supabase.projectId}`));
 
-      // Executar verificações
-      const report = await performChecks(config, databaseUrl);
+    // Executar verificações
+    const report = await performChecks(config, databaseUrl);
 
-      // Salvar relatório
-      const reportPath = path.resolve(options.output);
-      await writeJson(reportPath, report);
+    // Salvar relatório
+    const reportPath = path.resolve(options.output || 'check-report.json');
+    await writeJson(reportPath, report);
 
-      // Mostrar resumo
-      showCheckSummary(report);
+    // Mostrar resumo
+    showCheckSummary(report);
 
-      console.log(chalk.green('\n🎉 Verificação concluída!'));
-      console.log(chalk.blue(`📋 Relatório salvo em: ${reportPath}`));
+    console.log(chalk.green('\n🎉 Verificação concluída!'));
+    console.log(chalk.blue(`📋 Relatório salvo em: ${reportPath}`));
 
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro na verificação: ${error.message}`));
-      process.exit(1);
-    }
-  });
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro na verificação: ${error.message}`));
+    process.exit(1);
+  }
+};
 
 // Executar todas as verificações
 async function performChecks(config, databaseUrl) {
@@ -267,6 +265,4 @@ function showCheckSummary(report) {
   } else {
     console.log(chalk.yellow('⚠️ Algumas verificações falharam. Verifique o relatório completo.'));
   }
-}
-
-module.exports = checkCommand;
+}

package/src/commands/config.js

@@ -1,17 +1,12 @@
-/**
- * Comando de configuração do smoonb
- */
-
 const chalk = require('chalk');
 const fs = require('fs').promises;
 const path = require('path');
 const os = require('os');
+const { showBetaBanner } = require('../index');
 
-async function configCommand(options) {
-  console.log(chalk.red.bold('🚀 smoonb - EXPERIMENTAL VERSION'));
-  console.log(chalk.red.bold('⚠️  VERSÃO EXPERIMENTAL - NUNCA TESTADA EM PRODUÇÃO!'));
-  console.log(chalk.red.bold('🚨 USE POR SUA CONTA E RISCO - Pode causar perda de dados!'));
-  console.log(chalk.red.bold('❌ NÃO NOS RESPONSABILIZAMOS por qualquer perda de dados!\n'));
+// Exportar FUNÇÃO em vez de objeto Command
+module.exports = async (options) => {
+  showBetaBanner();
   
   console.log(chalk.cyan.bold('⚙️  Configuração do smoonb...\n'));
 
@@ -19,60 +14,116 @@ async function configCommand(options) {
     const configPath = path.join(process.cwd(), '.smoonbrc');
 
     if (options.init) {
-      // Inicializar configuração
-      const defaultConfig = {
-        supabase: {
-          projectId: '',
-          url: '',
-          serviceKey: '',
-          anonKey: '',
-          databaseUrl: ''
-        },
-        backup: {
-          includeFunctions: true,
-          includeStorage: true,
-          includeAuth: true,
-          includeRealtime: true,
-          outputDir: './backups',
-          pgDumpPath: 'C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe'
-        },
-        restore: {
-          cleanRestore: false,
-          verifyAfterRestore: true
-        }
-      };
-
-      await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
-      console.log(chalk.green('✅ Arquivo de configuração criado:'), configPath);
-      console.log(chalk.yellow('💡 Edite o arquivo para configurar suas credenciais Supabase'));
-
+      await initializeConfig(configPath);
     } else if (options.show) {
-      // Mostrar configuração atual
-      try {
-        const configContent = await fs.readFile(configPath, 'utf8');
-        const config = JSON.parse(configContent);
-        
-        console.log(chalk.green('📋 Configuração atual:'));
-        console.log(chalk.blue('📁 Arquivo:'), configPath);
-        console.log(chalk.gray(JSON.stringify(config, null, 2)));
-
-      } catch (error) {
-        console.log(chalk.yellow('⚠️  Arquivo de configuração não encontrado'));
-        console.log(chalk.yellow('💡 Use'), chalk.cyan('smoonb config --init'), chalk.yellow('para criar a configuração'));
-      }
-
+      await showConfig(configPath);
     } else {
-      // Mostrar ajuda
       console.log(chalk.yellow('💡 Opções disponíveis:'));
-      console.log(chalk.cyan('  --init'), chalk.gray('  Inicializar arquivo de configuração'));
-      console.log(chalk.cyan('  --show'), chalk.gray('  Mostrar configuração atual'));
-      console.log(chalk.blue('\n📁 Arquivo de configuração:'), configPath);
+      console.log(chalk.gray('  --init    Inicializar configuração'));
+      console.log(chalk.gray('  --show    Mostrar configuração atual'));
     }
 
   } catch (error) {
-    console.error(chalk.red.bold('❌ Erro durante a configuração:'), error.message);
+    console.error(chalk.red('❌ Erro na configuração:'), error.message);
     process.exit(1);
   }
+};
+
+// Inicializar configuração
+async function initializeConfig(configPath) {
+  console.log(chalk.blue('🔧 Inicializando configuração...'));
+
+  const defaultConfig = {
+    supabase: {
+      projectId: 'your-project-id-here',
+      url: 'https://your-project-id.supabase.co',
+      serviceKey: 'your-service-key-here',
+      anonKey: 'your-anon-key-here',
+      databaseUrl: 'postgresql://postgres:[password]@db.your-project-id.supabase.co:5432/postgres'
+    },
+    backup: {
+      includeFunctions: true,
+      includeStorage: true,
+      includeAuth: true,
+      includeRealtime: true,
+      outputDir: './backups'
+    },
+    restore: {
+      cleanRestore: true,
+      verifyAfterRestore: true
+    }
+  };
+
+  try {
+    await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+    console.log(chalk.green('✅ Arquivo de configuração criado: .smoonbrc'));
+    console.log(chalk.yellow('\n📝 Próximos passos:'));
+    console.log(chalk.gray('  1. Edite .smoonbrc com suas credenciais Supabase'));
+    console.log(chalk.gray('  2. Substitua os valores placeholder pelos reais'));
+    console.log(chalk.gray('  3. Execute: npx smoonb backup'));
+  } catch (error) {
+    throw new Error(`Falha ao criar arquivo de configuração: ${error.message}`);
+  }
 }
 
-module.exports = configCommand;
+// Mostrar configuração atual
+async function showConfig(configPath) {
+  console.log(chalk.blue('📋 Configuração atual:'));
+
+  try {
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const config = JSON.parse(configContent);
+
+    console.log(chalk.green('✅ Arquivo de configuração encontrado'));
+    console.log(chalk.gray(`   - Localização: ${configPath}`));
+    
+    if (config.supabase?.projectId && config.supabase.projectId !== 'your-project-id-here') {
+      console.log(chalk.gray(`   - Project ID: ${config.supabase.projectId}`));
+    } else {
+      console.log(chalk.yellow('   - Project ID: Não configurado'));
+    }
+    
+    if (config.supabase?.url && config.supabase.url !== 'https://your-project-id.supabase.co') {
+      console.log(chalk.gray(`   - Supabase URL: ${config.supabase.url}`));
+    } else {
+      console.log(chalk.yellow('   - Supabase URL: Não configurado'));
+    }
+    
+    if (config.supabase?.serviceKey && config.supabase.serviceKey !== 'your-service-key-here') {
+      console.log(chalk.gray('   - Service Key: Configurada'));
+    } else {
+      console.log(chalk.yellow('   - Service Key: Não configurada'));
+    }
+    
+    if (config.supabase?.anonKey && config.supabase.anonKey !== 'your-anon-key-here') {
+      console.log(chalk.gray('   - Anon Key: Configurada'));
+    } else {
+      console.log(chalk.yellow('   - Anon Key: Não configurada'));
+    }
+    
+    if (config.supabase?.databaseUrl && !config.supabase.databaseUrl.includes('[password]')) {
+      console.log(chalk.gray('   - Database URL: Configurada'));
+    } else {
+      console.log(chalk.yellow('   - Database URL: Não configurada'));
+    }
+
+    console.log(chalk.blue('\n📊 Configurações de backup:'));
+    console.log(chalk.gray(`   - Output Dir: ${config.backup?.outputDir || './backups'}`));
+    console.log(chalk.gray(`   - Include Functions: ${config.backup?.includeFunctions || true}`));
+    console.log(chalk.gray(`   - Include Storage: ${config.backup?.includeStorage || true}`));
+    console.log(chalk.gray(`   - Include Auth: ${config.backup?.includeAuth || true}`));
+    console.log(chalk.gray(`   - Include Realtime: ${config.backup?.includeRealtime || true}`));
+
+    console.log(chalk.blue('\n🔄 Configurações de restore:'));
+    console.log(chalk.gray(`   - Clean Restore: ${config.restore?.cleanRestore || true}`));
+    console.log(chalk.gray(`   - Verify After Restore: ${config.restore?.verifyAfterRestore || true}`));
+
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log(chalk.yellow('⚠️  Arquivo de configuração não encontrado'));
+      console.log(chalk.gray('   - Use: npx smoonb config --init'));
+    } else {
+      throw new Error(`Falha ao ler arquivo de configuração: ${error.message}`);
+    }
+  }
+}

package/src/commands/functions.js

@@ -1,149 +1,133 @@
-const { Command } = require('commander');
 const chalk = require('chalk');
 const { ensureBin, runCommand } = require('../utils/cli');
 const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../index');
 
-const functionsCommand = new Command('functions')
-  .description('Gerenciar Edge Functions do Supabase')
-  .action(async () => {
-    showBetaBanner();
-    
-    try {
-      // Verificar se Supabase CLI está disponível
-      const supabasePath = await ensureBin('supabase');
-      if (!supabasePath) {
-        console.error(chalk.red('❌ Supabase CLI não encontrado'));
-        console.log(chalk.yellow('💡 Instale o Supabase CLI:'));
-        console.log(chalk.yellow('  npm install -g supabase'));
-        console.log(chalk.yellow('  ou visite: https://supabase.com/docs/guides/cli'));
-        process.exit(1);
-      }
-
-      console.log(chalk.blue('⚡ Comandos disponíveis para Edge Functions:'));
-      console.log(chalk.yellow('\n📋 Listar functions:'));
-      console.log(chalk.gray('  npx smoonb functions list'));
-      console.log(chalk.yellow('\n🚀 Deploy functions:'));
-      console.log(chalk.gray('  npx smoonb functions push'));
-      console.log(chalk.yellow('\n📥 Pull functions (se disponível):'));
-      console.log(chalk.gray('  npx smoonb functions pull'));
-      console.log(chalk.yellow('\n💡 Para mais opções, use o Supabase CLI diretamente:'));
-      console.log(chalk.gray('  supabase functions --help'));
-
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro: ${error.message}`));
+// Exportar FUNÇÃO em vez de objeto Command
+module.exports = async (options) => {
+  showBetaBanner();
+  
+  try {
+    // Verificar se Supabase CLI está disponível
+    const supabasePath = await ensureBin('supabase');
+    if (!supabasePath) {
+      console.error(chalk.red('❌ Supabase CLI não encontrado'));
+      console.log(chalk.yellow('💡 Instale o Supabase CLI:'));
+      console.log(chalk.yellow('  npm install -g supabase'));
+      console.log(chalk.yellow('  ou visite: https://supabase.com/docs/guides/cli'));
       process.exit(1);
     }
-  });
-
-// Subcomando para listar functions
-functionsCommand
-  .command('list')
-  .description('Listar Edge Functions do projeto')
-  .action(async () => {
-    showBetaBanner();
-    
-    try {
-      const config = await readConfig();
-      validateFor(config, 'inventory');
-
-      console.log(chalk.blue('📋 Listando Edge Functions...'));
-
-      const { stdout, stderr } = await runCommand(
-        'supabase functions list',
-        {
-          env: { 
-            ...process.env, 
-            SUPABASE_ACCESS_TOKEN: config.supabase.serviceKey 
-          }
-        }
-      );
 
-      if (stderr && !stderr.includes('WARN')) {
-        console.log(chalk.yellow(`⚠️ Avisos: ${stderr}`));
+    console.log(chalk.blue('⚡ Comandos disponíveis para Edge Functions:'));
+    console.log(chalk.yellow('\n📋 Listar functions:'));
+    console.log(chalk.gray('  npx smoonb functions list'));
+    console.log(chalk.yellow('\n🚀 Deploy functions:'));
+    console.log(chalk.gray('  npx smoonb functions push'));
+    console.log(chalk.yellow('\n📥 Pull functions (se disponível):'));
+    console.log(chalk.gray('  npx smoonb functions pull'));
+    console.log(chalk.yellow('\n💡 Para mais opções, use o Supabase CLI diretamente:'));
+    console.log(chalk.gray('  supabase functions --help'));
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+// Função para listar functions
+async function listFunctions() {
+  try {
+    const config = await readConfig();
+    validateFor(config, 'inventory');
+
+    console.log(chalk.blue('📋 Listando Edge Functions...'));
+
+    const { stdout, stderr } = await runCommand(
+      'supabase functions list',
+      {
+        env: { 
+          ...process.env, 
+          SUPABASE_ACCESS_TOKEN: config.supabase.serviceKey 
+        }
       }
+    );
+
+    if (stderr && !stderr.includes('WARN')) {
+      console.log(chalk.yellow(`⚠️ Avisos: ${stderr}`));
+    }
+
+    console.log(chalk.green('✅ Edge Functions listadas:'));
+    console.log(stdout);
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro ao listar functions: ${error.message}`));
+    process.exit(1);
+  }
+}
 
-      console.log(chalk.green('✅ Edge Functions listadas:'));
-      console.log(stdout);
+// Função para deploy de functions
+async function pushFunctions(projectRef) {
+  try {
+    const config = await readConfig();
+    const projectId = projectRef || config.supabase.projectId;
 
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro ao listar functions: ${error.message}`));
+    if (!projectId) {
+      console.error(chalk.red('❌ Project ID não encontrado'));
+      console.log(chalk.yellow('💡 Use: npx smoonb functions push --project-ref <id>'));
       process.exit(1);
     }
-  });
-
-// Subcomando para deploy de functions
-functionsCommand
-  .command('push')
-  .description('Fazer deploy das Edge Functions')
-  .option('--project-ref <ref>', 'ID do projeto Supabase')
-  .action(async (options) => {
-    showBetaBanner();
-    
-    try {
-      const config = await readConfig();
-      const projectRef = options.projectRef || config.supabase.projectId;
-
-      if (!projectRef) {
-        console.error(chalk.red('❌ Project ID não encontrado'));
-        console.log(chalk.yellow('💡 Use: npx smoonb functions push --project-ref <id>'));
-        process.exit(1);
-      }
 
-      console.log(chalk.blue(`🚀 Fazendo deploy das Edge Functions para: ${projectRef}`));
+    console.log(chalk.blue(`🚀 Fazendo deploy das Edge Functions para: ${projectId}`));
 
-      const { stdout, stderr } = await runCommand(
-        `supabase functions deploy --project-ref ${projectRef}`,
-        {
-          env: { 
-            ...process.env, 
-            SUPABASE_ACCESS_TOKEN: config.supabase.serviceKey 
-          }
+    const { stdout, stderr } = await runCommand(
+      `supabase functions deploy --project-ref ${projectId}`,
+      {
+        env: { 
+          ...process.env, 
+          SUPABASE_ACCESS_TOKEN: config.supabase.serviceKey 
         }
-      );
-
-      if (stderr && !stderr.includes('WARN')) {
-        console.log(chalk.yellow(`⚠️ Avisos: ${stderr}`));
       }
+    );
 
-      console.log(chalk.green('✅ Deploy concluído:'));
-      console.log(stdout);
-
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro no deploy: ${error.message}`));
-      process.exit(1);
+    if (stderr && !stderr.includes('WARN')) {
+      console.log(chalk.yellow(`⚠️ Avisos: ${stderr}`));
     }
-  });
-
-// Subcomando para pull de functions
-functionsCommand
-  .command('pull')
-  .description('Baixar Edge Functions do projeto remoto')
-  .option('--project-ref <ref>', 'ID do projeto Supabase')
-  .action(async (options) => {
-    showBetaBanner();
-    
-    try {
-      const config = await readConfig();
-      const projectRef = options.projectRef || config.supabase.projectId;
-
-      if (!projectRef) {
-        console.error(chalk.red('❌ Project ID não encontrado'));
-        console.log(chalk.yellow('💡 Use: npx smoonb functions pull --project-ref <id>'));
-        process.exit(1);
-      }
 
-      console.log(chalk.yellow('⚠️ Pull de Edge Functions não é oficialmente suportado pelo Supabase CLI'));
-      console.log(chalk.yellow('💡 Para baixar código das functions remotas:'));
-      console.log(chalk.gray('  1. Use o Dashboard do Supabase'));
-      console.log(chalk.gray('  2. Ou clone o código do seu repositório Git'));
-      console.log(chalk.gray('  3. Ou use a API do Supabase diretamente'));
-      console.log(chalk.blue('\n📚 Documentação: https://supabase.com/docs/guides/functions'));
+    console.log(chalk.green('✅ Deploy concluído:'));
+    console.log(stdout);
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro no deploy: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// Função para pull de functions
+async function pullFunctions(projectRef) {
+  try {
+    const config = await readConfig();
+    const projectId = projectRef || config.supabase.projectId;
 
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro: ${error.message}`));
+    if (!projectId) {
+      console.error(chalk.red('❌ Project ID não encontrado'));
+      console.log(chalk.yellow('💡 Use: npx smoonb functions pull --project-ref <id>'));
       process.exit(1);
     }
-  });
 
-module.exports = functionsCommand;
+    console.log(chalk.yellow('⚠️ Pull de Edge Functions não é oficialmente suportado pelo Supabase CLI'));
+    console.log(chalk.yellow('💡 Para baixar código das functions remotas:'));
+    console.log(chalk.gray('  1. Use o Dashboard do Supabase'));
+    console.log(chalk.gray('  2. Ou clone o código do seu repositório Git'));
+    console.log(chalk.gray('  3. Ou use a API do Supabase diretamente'));
+    console.log(chalk.blue('\n📚 Documentação: https://supabase.com/docs/guides/functions'));
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// Exportar funções auxiliares para uso futuro
+module.exports.list = listFunctions;
+module.exports.push = pushFunctions;
+module.exports.pull = pullFunctions;

package/src/commands/restore.js

@@ -1,91 +1,182 @@
-const { Command } = require('commander');
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
+const inquirer = require('inquirer');
 const { ensureBin, runCommand } = require('../utils/cli');
 const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../index');
 
-const restoreCommand = new Command('restore')
-  .description('Restaurar backup do projeto Supabase usando psql')
-  .option('-b, --backup-dir <dir>', 'Diretório do backup')
-  .option('--db-url <url>', 'URL da database de destino (override)')
-  .action(async (options) => {
-    showBetaBanner();
+// Exportar FUNÇÃO em vez de objeto Command
+module.exports = async (options) => {
+  showBetaBanner();
+  
+  try {
+    // Verificar se psql está disponível
+    const psqlPath = await ensureBin('psql');
+    if (!psqlPath) {
+      console.error(chalk.red('❌ psql não encontrado'));
+      console.log(chalk.yellow('💡 Instale PostgreSQL:'));
+      console.log(chalk.yellow('  https://www.postgresql.org/download/'));
+      process.exit(1);
+    }
+
+    // Carregar configuração
+    const config = await readConfig();
+    validateFor(config, 'restore');
+
+    // Resolver URL da database
+    const databaseUrl = options.dbUrl || config.supabase.databaseUrl;
+    if (!databaseUrl) {
+      console.error(chalk.red('❌ databaseUrl não configurada'));
+      console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc ou use --db-url'));
+      process.exit(1);
+    }
+
+    console.log(chalk.blue(`🔍 Procurando backups em: ${config.backup.outputDir || './backups'}`));
+
+    // Listar backups disponíveis
+    const backups = await listAvailableBackups(config.backup.outputDir || './backups');
     
-    try {
-      // Verificar se psql está disponível
-      const psqlPath = await ensureBin('psql');
-      if (!psqlPath) {
-        console.error(chalk.red('❌ psql não encontrado'));
-        console.log(chalk.yellow('💡 Instale PostgreSQL:'));
-        console.log(chalk.yellow('  https://www.postgresql.org/download/'));
-        process.exit(1);
-      }
+    if (backups.length === 0) {
+      console.error(chalk.red('❌ Nenhum backup encontrado'));
+      console.log(chalk.yellow('💡 Execute primeiro: npx smoonb backup'));
+      process.exit(1);
+    }
 
-      // Carregar configuração
-      const config = await readConfig();
-      validateFor(config, 'restore');
+    // Seleção interativa do backup
+    const selectedBackup = await selectBackup(backups);
+    
+    console.log(chalk.blue(`🚀 Iniciando restauração do backup: ${selectedBackup.name}`));
+    console.log(chalk.blue(`🎯 Database destino: ${databaseUrl.replace(/:[^:]*@/, ':***@')}`));
 
-      // Resolver URL da database
-      const databaseUrl = options.dbUrl || config.supabase.databaseUrl;
-      if (!databaseUrl) {
-        console.error(chalk.red('❌ databaseUrl não configurada'));
-        console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc ou use --db-url'));
-        process.exit(1);
-      }
+    // Verificar se é clean restore
+    if (config.restore.cleanRestore) {
+      await checkCleanRestore(databaseUrl);
+    }
 
-      // Resolver diretório do backup
-      let backupDir = options.backupDir;
-      if (!backupDir) {
-        // Procurar backup mais recente
-        const backupsDir = config.backup.outputDir || './backups';
-        if (fs.existsSync(backupsDir)) {
-          const backups = fs.readdirSync(backupsDir)
-            .filter(dir => dir.startsWith('backup-'))
-            .sort()
-            .reverse();
-          
-          if (backups.length > 0) {
-            backupDir = path.join(backupsDir, backups[0]);
-            console.log(chalk.blue(`📁 Usando backup mais recente: ${backups[0]}`));
-          }
-        }
-      }
+    // Executar restauração
+    await performRestore(selectedBackup.path, databaseUrl);
 
-      if (!backupDir || !fs.existsSync(backupDir)) {
-        console.error(chalk.red('❌ Diretório de backup não encontrado'));
-        console.log(chalk.yellow('💡 Use: npx smoonb restore --backup-dir <caminho>'));
-        process.exit(1);
-      }
+    // Verificação pós-restore
+    if (config.restore.verifyAfterRestore) {
+      console.log(chalk.blue('\n🔍 Executando verificação pós-restore...'));
+      console.log(chalk.yellow('💡 Execute manualmente: npx smoonb check'));
+    }
 
-      console.log(chalk.blue(`🚀 Iniciando restauração do backup: ${path.basename(backupDir)}`));
-      console.log(chalk.blue(`🎯 Database destino: ${databaseUrl.replace(/:[^:]*@/, ':***@')}`));
+    console.log(chalk.green('\n🎉 Restauração concluída com sucesso!'));
 
-      // Verificar se é clean restore
-      if (config.restore.cleanRestore) {
-        await checkCleanRestore(databaseUrl);
-      }
+  } catch (error) {
+    console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+// Listar backups disponíveis
+async function listAvailableBackups(backupsDir) {
+  if (!fs.existsSync(backupsDir)) {
+    return [];
+  }
 
-      // Executar restauração
-      await performRestore(backupDir, databaseUrl);
+  const items = fs.readdirSync(backupsDir, { withFileTypes: true });
+  const backups = [];
 
-      // Verificação pós-restore
-      if (config.restore.verifyAfterRestore) {
-        console.log(chalk.blue('\n🔍 Executando verificação pós-restore...'));
-        // TODO: Implementar verificação automática
-        console.log(chalk.yellow('⚠️ Verificação automática não implementada ainda'));
-        console.log(chalk.yellow('💡 Execute manualmente: npx smoonb check'));
+  for (const item of items) {
+    if (item.isDirectory() && item.name.startsWith('backup-')) {
+      const backupPath = path.join(backupsDir, item.name);
+      const manifestPath = path.join(backupPath, 'backup-manifest.json');
+      
+      let manifest = null;
+      if (fs.existsSync(manifestPath)) {
+        try {
+          manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        } catch (error) {
+          console.warn(chalk.yellow(`⚠️ Erro ao ler manifesto: ${item.name}`));
+        }
       }
 
-      console.log(chalk.green('\n🎉 Restauração concluída com sucesso!'));
+      const stats = fs.statSync(backupPath);
+      
+      backups.push({
+        name: item.name,
+        path: backupPath,
+        created: manifest?.created_at || stats.birthtime.toISOString(),
+        projectId: manifest?.project_id || 'Desconhecido',
+        size: getDirectorySize(backupPath),
+        manifest: manifest
+      });
+    }
+  }
+
+  // Ordenar por data de criação (mais recente primeiro)
+  return backups.sort((a, b) => new Date(b.created) - new Date(a.created));
+}
 
-    } catch (error) {
-      console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
-      process.exit(1);
+// Calcular tamanho do diretório
+function getDirectorySize(dirPath) {
+  let totalSize = 0;
+  
+  function calculateSize(itemPath) {
+    const stats = fs.statSync(itemPath);
+    
+    if (stats.isDirectory()) {
+      const items = fs.readdirSync(itemPath);
+      for (const item of items) {
+        calculateSize(path.join(itemPath, item));
+      }
+    } else {
+      totalSize += stats.size;
     }
+  }
+  
+  try {
+    calculateSize(dirPath);
+  } catch (error) {
+    // Ignorar erros de acesso
+  }
+  
+  return formatBytes(totalSize);
+}
+
+// Formatar bytes em formato legível
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+// Seleção interativa do backup
+async function selectBackup(backups) {
+  console.log(chalk.blue('\n📋 Backups disponíveis:'));
+  console.log(chalk.blue('═'.repeat(80)));
+  
+  const choices = backups.map((backup, index) => {
+    const date = new Date(backup.created).toLocaleString('pt-BR');
+    const projectInfo = backup.projectId !== 'Desconhecido' ? ` (${backup.projectId})` : '';
+    
+    return {
+      name: `${index + 1}. ${backup.name}${projectInfo}\n   📅 ${date} | 📦 ${backup.size}`,
+      value: backup,
+      short: backup.name
+    };
   });
 
+  const { selectedBackup } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedBackup',
+      message: 'Selecione o backup para restaurar:',
+      choices: choices,
+      pageSize: 10
+    }
+  ]);
+
+  return selectedBackup;
+}
+
 // Verificar se é possível fazer clean restore
 async function checkCleanRestore(databaseUrl) {
   try {
@@ -158,6 +249,4 @@ async function performRestore(backupDir, databaseUrl) {
       throw new Error(`Falha ao executar ${sqlFile}: ${error.message}`);
     }
   }
-}
-
-module.exports = restoreCommand;
+}

package/src/services/introspect.js

@@ -1,5 +1,5 @@
 const { createClient } = require('@supabase/supabase-js');
-const { runCommand } = require('./cli');
+const { runCommand } = require('../utils/cli');
 
 /**
  * Serviço de introspecção do banco de dados Supabase