smoonb 0.0.7 → 0.0.9

package/src/commands/restore.js

@@ -1,335 +1,257 @@
-/**
- * Comando de restauração completa do projeto Supabase
- * Implementação técnica real com processo DROP→CREATE→RESTORE
- */
-
+const { Command } = require('commander');
 const chalk = require('chalk');
-const { execSync } = require('child_process');
-const fs = require('fs');
 const path = require('path');
-const { getProjectId } = require('../utils/supabase');
-
-/**
- * Restauração completa do projeto Supabase
- * Processo seguro: DROP → CREATE → RESTORE (nunca restore sobre banco existente)
- */
-async function restoreCommand(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'));
-  
-  console.log(chalk.cyan.bold('🔄 Iniciando restauração COMPLETA do projeto Supabase...\n'));
+const fs = require('fs');
+const inquirer = require('inquirer');
+const { ensureBin, runCommand } = require('../utils/cli');
+const { readConfig, validateFor } = require('../utils/config');
+const { showBetaBanner } = require('../index');
 
-  try {
-    // Obter projectId (da opção ou da configuração)
-    const projectId = options.projectId || getProjectId();
+const restoreCommand = new Command('restore')
+  .description('Restaurar backup do projeto Supabase usando psql (modo interativo)')
+  .option('--db-url <url>', 'URL da database de destino (override)')
+  .action(async (options) => {
+    showBetaBanner();
     
-    if (!projectId) {
-      console.error(chalk.red.bold('❌ Erro: Project ID não encontrado'));
-      console.log(chalk.yellow('💡 Opções:'));
-      console.log(chalk.gray('   1. Use: smoonb restore --project-id <seu-project-id>'));
-      console.log(chalk.gray('   2. Configure: smoonb config --init'));
-      console.log(chalk.gray('   3. Ou defina SUPABASE_PROJECT_ID no ambiente'));
-      console.log(chalk.gray('   4. Ou edite ~/.smoonbrc e configure o projectId'));
-      process.exit(1);
-    }
-
-    console.log(chalk.blue('🆔 Project ID:'), projectId);
-
-    if (!options.backupDir) {
-      console.error(chalk.red.bold('❌ Erro: Diretório de backup é obrigatório'));
-      console.log(chalk.yellow('💡 Use: smoonb restore --project-id <seu-project-id> --backup-dir <diretorio-backup>'));
-      process.exit(1);
-    }
-
-    // Verificar se o diretório de backup existe
-    const backupPath = path.resolve(options.backupDir);
     try {
-      await fs.promises.access(backupPath);
-    } catch (error) {
-      console.error(chalk.red.bold('❌ Erro: Diretório de backup não encontrado:'), backupPath);
-      process.exit(1);
-    }
-
-    // Ler manifesto do backup
-    const manifestPath = path.join(backupPath, 'backup-manifest.json');
-    let manifest = null;
-    try {
-      const manifestContent = await fs.promises.readFile(manifestPath, 'utf8');
-      manifest = JSON.parse(manifestContent);
-      console.log(chalk.green('✅ Manifesto do backup encontrado'));
-      console.log(chalk.gray('   - Projeto origem:'), manifest.projectId);
-      console.log(chalk.gray('   - Data do backup:'), manifest.timestamp);
-    } catch (error) {
-      console.log(chalk.yellow('⚠️  Manifesto do backup não encontrado, continuando...'));
-    }
+      // 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);
+      }
 
-    console.log(chalk.green('✅ Diretório de backup encontrado:'), backupPath);
+      // Carregar configuração
+      const config = await readConfig();
+      validateFor(config, 'restore');
 
-    // 1. RESTAURAÇÃO DA DATABASE (processo seguro)
-    if (manifest?.files?.database) {
-      console.log(chalk.blue.bold('\n📊 1/5 - Restauração da Database PostgreSQL...'));
-      const dbBackupFile = path.join(backupPath, manifest.files.database);
-      const dbResult = await restoreDatabase(dbBackupFile, options.projectId);
-      
-      if (dbResult.success) {
-        console.log(chalk.green('✅ Database restaurada com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Restauração da database falhou:'), dbResult.error);
+      // 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);
       }
-    }
 
-    // 2. RESTAURAÇÃO DAS EDGE FUNCTIONS
-    if (manifest?.files?.functions) {
-      console.log(chalk.blue.bold('\n⚡ 2/5 - Restauração das Edge Functions...'));
-      const functionsDir = path.join(backupPath, 'functions');
-      const functionsResult = await restoreEdgeFunctions(functionsDir, options.projectId);
+      console.log(chalk.blue(`🔍 Procurando backups em: ${config.backup.outputDir || './backups'}`));
+
+      // Listar backups disponíveis
+      const backups = await listAvailableBackups(config.backup.outputDir || './backups');
       
-      if (functionsResult.success) {
-        console.log(chalk.green('✅ Edge Functions restauradas com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Restauração das Edge Functions falhou:'), functionsResult.error);
+      if (backups.length === 0) {
+        console.error(chalk.red('❌ Nenhum backup encontrado'));
+        console.log(chalk.yellow('💡 Execute primeiro: npx smoonb backup'));
+        process.exit(1);
       }
-    }
 
-    // 3. RESTAURAÇÃO DAS CONFIGURAÇÕES DE AUTH
-    if (manifest?.files?.auth) {
-      console.log(chalk.blue.bold('\n🔐 3/5 - Restauração das configurações de Auth...'));
-      const authConfigPath = path.join(backupPath, 'auth-config.json');
-      const authResult = await restoreAuthSettings(authConfigPath, options.projectId);
+      // Seleção interativa do backup
+      const selectedBackup = await selectBackup(backups);
       
-      if (authResult.success) {
-        console.log(chalk.green('✅ Auth settings restauradas com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Restauração das configurações de Auth falhou:'), authResult.error);
+      console.log(chalk.blue(`🚀 Iniciando restauração do backup: ${selectedBackup.name}`));
+      console.log(chalk.blue(`🎯 Database destino: ${databaseUrl.replace(/:[^:]*@/, ':***@')}`));
+
+      // Verificar se é clean restore
+      if (config.restore.cleanRestore) {
+        await checkCleanRestore(databaseUrl);
       }
-    }
 
-    // 4. RESTAURAÇÃO DOS STORAGE OBJECTS
-    if (manifest?.files?.storage) {
-      console.log(chalk.blue.bold('\n📁 4/5 - Restauração dos Storage Objects...'));
-      const storageDir = path.join(backupPath, 'storage');
-      const storageResult = await restoreStorageObjects(storageDir, options.projectId);
-      
-      if (storageResult.success) {
-        console.log(chalk.green('✅ Storage Objects restaurados com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Restauração dos Storage Objects falhou:'), storageResult.error);
+      // Executar restauração
+      await performRestore(selectedBackup.path, databaseUrl);
+
+      // 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.green('\n🎉 Restauração concluída com sucesso!'));
+
+    } catch (error) {
+      console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
+      process.exit(1);
     }
+  });
 
-    // 5. RESTAURAÇÃO DAS CONFIGURAÇÕES DE REALTIME
-    if (manifest?.files?.realtime) {
-      console.log(chalk.blue.bold('\n🔄 5/5 - Restauração das configurações de Realtime...'));
-      const realtimeConfigPath = path.join(backupPath, 'realtime-config.json');
-      const realtimeResult = await restoreRealtimeSettings(realtimeConfigPath, options.projectId);
+// Listar backups disponíveis
+async function listAvailableBackups(backupsDir) {
+  if (!fs.existsSync(backupsDir)) {
+    return [];
+  }
+
+  const items = fs.readdirSync(backupsDir, { withFileTypes: true });
+  const backups = [];
+
+  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');
       
-      if (realtimeResult.success) {
-        console.log(chalk.green('✅ Realtime settings restauradas com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Restauração das configurações de Realtime falhou:'), realtimeResult.error);
+      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}`));
+        }
       }
-    }
 
-    // Verificação pós-restore (se solicitada)
-    if (options.verify) {
-      console.log(chalk.blue.bold('\n🔍 Verificação pós-restore...'));
-      const checkResult = await postRestoreVerification(options.projectId);
+      const stats = fs.statSync(backupPath);
       
-      if (checkResult.success) {
-        console.log(chalk.green('✅ Verificação concluída com sucesso!'));
-      } else {
-        console.log(chalk.yellow('⚠️  Verificação encontrou problemas:'), checkResult.issues);
-      }
+      backups.push({
+        name: item.name,
+        path: backupPath,
+        created: manifest?.created_at || stats.birthtime.toISOString(),
+        projectId: manifest?.project_id || 'Desconhecido',
+        size: getDirectorySize(backupPath),
+        manifest: manifest
+      });
     }
-
-    console.log(chalk.green.bold('\n🎉 RESTAURAÇÃO COMPLETA FINALIZADA!'));
-    console.log(chalk.blue('📁 Backup:'), backupPath);
-    console.log(chalk.blue('🆔 Project ID:'), options.projectId);
-    console.log(chalk.yellow('\n💡 Use "smoonb check" para verificar a integridade do projeto restaurado'));
-
-  } catch (error) {
-    console.error(chalk.red.bold('❌ Erro durante a restauração:'), error.message);
-    console.error(chalk.gray('Stack trace:'), error.stack);
-    process.exit(1);
   }
+
+  // Ordenar por data de criação (mais recente primeiro)
+  return backups.sort((a, b) => new Date(b.created) - new Date(a.created));
 }
 
-/**
- * Restauração da database PostgreSQL
- * Processo seguro: DROP → CREATE → RESTORE
- */
-async function restoreDatabase(backupFile, projectId) {
-  try {
-    // Construir URL de conexão
-    const dbUrl = process.env.DATABASE_URL || `postgresql://postgres:[password]@db.${projectId}.supabase.co:5432/postgres`;
-    const dbName = new URL(dbUrl).pathname.slice(1);
-    const baseUrl = dbUrl.replace(`/${dbName}`, '');
-    
-    console.log(chalk.gray('🔥 Processo de Restauração Limpa iniciado...'));
+// Calcular tamanho do diretório
+function getDirectorySize(dirPath) {
+  let totalSize = 0;
+  
+  function calculateSize(itemPath) {
+    const stats = fs.statSync(itemPath);
     
-    // 1. DROPAR banco existente (força desconexão)
-    console.log(chalk.gray('   - Step 1/3: Removendo banco antigo...'));
-    try {
-      const dropCmd = `dropdb "${dbUrl}" --if-exists -f`;
-      execSync(dropCmd, { stdio: 'pipe' }); // Oculta erro se não existir
-    } catch (error) {
-      console.log(chalk.gray('     (Banco não existia, continuando...)'));
+    if (stats.isDirectory()) {
+      const items = fs.readdirSync(itemPath);
+      for (const item of items) {
+        calculateSize(path.join(itemPath, item));
+      }
+    } else {
+      totalSize += stats.size;
     }
-    
-    // 2. CRIAR banco novo e vazio
-    console.log(chalk.gray('   - Step 2/3: Criando banco vazio...'));
-    const createCmd = `createdb "${baseUrl}/${dbName}"`;
-    execSync(createCmd, { stdio: 'pipe' });
-    
-    // 3. RESTAURAR backup no banco vazio
-    console.log(chalk.gray('   - Step 3/3: Restaurando backup...'));
-    const restoreCmd = `pg_restore -d "${dbUrl}" --clean --if-exists --single-transaction "${backupFile}"`;
-    execSync(restoreCmd, { stdio: 'pipe' });
-    
-    console.log(chalk.green('✅ Restauração da database concluída com sucesso!'));
-    return { success: true };
-    
-  } catch (error) {
-    console.log(chalk.yellow('⚠️  Restauração da database falhou (credenciais não configuradas)'));
-    console.log(chalk.gray('   - Configure DATABASE_URL ou use smoonb config --init'));
-    return { success: false, error: error.message };
   }
-}
-
-/**
- * Restauração das Edge Functions via Supabase CLI
- */
-async function restoreEdgeFunctions(functionsDir, projectId) {
+  
   try {
-    if (!fs.existsSync(functionsDir)) {
-      console.log(chalk.gray('   - Nenhuma Edge Function encontrada no backup'));
-      return { success: true };
-    }
-    
-    console.log(chalk.gray('   - Deploy das Edge Functions via Supabase CLI...'));
-    
-    // Verificar se Supabase CLI está instalado
-    try {
-      execSync('supabase --version', { stdio: 'pipe' });
-    } catch (error) {
-      console.log(chalk.yellow('⚠️  Supabase CLI não encontrado'));
-      console.log(chalk.gray('   - Instale: npm install -g supabase'));
-      return { success: false, error: 'Supabase CLI não encontrado' };
-    }
-    
-    // Deploy functions via Supabase CLI
-    const deployCmd = `supabase functions deploy --project-ref ${projectId}`;
-    execSync(deployCmd, { stdio: 'pipe' });
-    
-    return { success: true };
+    calculateSize(dirPath);
   } catch (error) {
-    return { success: false, error: error.message };
+    // Ignorar erros de acesso
   }
+  
+  return formatBytes(totalSize);
 }
 
-/**
- * Restauração das configurações de Auth
- */
-async function restoreAuthSettings(authConfigPath, projectId) {
-  try {
-    if (!fs.existsSync(authConfigPath)) {
-      console.log(chalk.gray('   - Nenhuma configuração de Auth encontrada no backup'));
-      return { success: true };
-    }
-    
-    console.log(chalk.gray('   - Restaurando configurações de Auth...'));
-    
-    // TODO: Implementar restauração real via Supabase API
-    const authConfig = JSON.parse(await fs.promises.readFile(authConfigPath, 'utf8'));
-    console.log(chalk.gray('   - Configurações carregadas:', Object.keys(authConfig).length, 'itens'));
-    
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
+// 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];
 }
 
-/**
- * Restauração dos Storage Objects
- */
-async function restoreStorageObjects(storageDir, projectId) {
-  try {
-    if (!fs.existsSync(storageDir)) {
-      console.log(chalk.gray('   - Nenhum Storage Object encontrado no backup'));
-      return { success: true };
-    }
-    
-    console.log(chalk.gray('   - Restaurando Storage Objects...'));
+// 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})` : '';
     
-    // TODO: Implementar restauração real via Supabase API
-    const storageConfigPath = path.join(storageDir, 'storage-config.json');
-    if (fs.existsSync(storageConfigPath)) {
-      const storageConfig = JSON.parse(await fs.promises.readFile(storageConfigPath, 'utf8'));
-      console.log(chalk.gray('   - Configurações carregadas:', Object.keys(storageConfig).length, 'itens'));
+    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 { success: true };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
+  ]);
+
+  return selectedBackup;
 }
 
-/**
- * Restauração das configurações de Realtime
- */
-async function restoreRealtimeSettings(realtimeConfigPath, projectId) {
+// Verificar se é possível fazer clean restore
+async function checkCleanRestore(databaseUrl) {
   try {
-    if (!fs.existsSync(realtimeConfigPath)) {
-      console.log(chalk.gray('   - Nenhuma configuração de Realtime encontrada no backup'));
-      return { success: true };
-    }
+    console.log(chalk.blue('🔍 Verificando se database está vazia...'));
     
-    console.log(chalk.gray('   - Restaurando configurações de Realtime...'));
+    // Verificar se existem tabelas no schema public
+    const checkQuery = `
+      SELECT COUNT(*) as table_count 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' AND table_type = 'BASE TABLE';
+    `;
     
-    // TODO: Implementar restauração real via Supabase API
-    const realtimeConfig = JSON.parse(await fs.promises.readFile(realtimeConfigPath, 'utf8'));
-    console.log(chalk.gray('   - Configurações carregadas:', Object.keys(realtimeConfig).length, 'itens'));
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${checkQuery}"`
+    );
+    
+    const tableCount = parseInt(stdout.trim());
+    
+    if (tableCount > 0) {
+      console.error(chalk.red('❌ Database não está vazia!'));
+      console.log(chalk.yellow('💡 Para clean restore, a database deve estar vazia'));
+      console.log(chalk.yellow('💡 Opções:'));
+      console.log(chalk.yellow('  1. Criar uma nova database'));
+      console.log(chalk.yellow('  2. Desabilitar cleanRestore no .smoonbrc'));
+      console.log(chalk.yellow('  3. Limpar manualmente a database'));
+      process.exit(1);
+    }
+    
+    console.log(chalk.green('✅ Database está vazia, prosseguindo com clean restore'));
     
-    return { success: true };
   } catch (error) {
-    return { success: false, error: error.message };
+    console.log(chalk.yellow(`⚠️ Não foi possível verificar database: ${error.message}`));
+    console.log(chalk.yellow('💡 Prosseguindo com restauração...'));
   }
 }
 
-/**
- * Verificação pós-restore
- */
-async function postRestoreVerification(projectId) {
-  try {
-    console.log(chalk.gray('   - Executando verificações básicas...'));
-    
-    // Verificações básicas
-    const checks = [
-      { name: 'Database Connection', status: 'pending' },
-      { name: 'Edge Functions', status: 'pending' },
-      { name: 'Auth Providers', status: 'pending' },
-      { name: 'Storage Buckets', status: 'pending' },
-      { name: 'Realtime Settings', status: 'pending' }
-    ];
+// Executar restauração usando psql
+async function performRestore(backupDir, databaseUrl) {
+  const sqlFiles = ['roles.sql', 'schema.sql', 'data.sql'];
+  
+  for (const sqlFile of sqlFiles) {
+    const filePath = path.join(backupDir, sqlFile);
     
-    // Simular verificações (TODO: implementar verificações reais)
-    checks.forEach(check => {
-      check.status = 'ok';
-    });
+    if (!fs.existsSync(filePath)) {
+      console.log(chalk.yellow(`⚠️ Arquivo ${sqlFile} não encontrado, pulando...`));
+      continue;
+    }
     
-    // Mostrar resultado
-    checks.forEach(check => {
-      const icon = check.status === 'ok' ? '✅' : 
-                   check.status === 'warning' ? '⚠️' : '❌';
-      console.log(chalk.gray(`     ${icon} ${check.name}`));
-    });
+    console.log(chalk.blue(`📄 Executando ${sqlFile}...`));
     
-    return { success: true };
-  } catch (error) {
-    return { success: false, issues: [error.message] };
+    try {
+      let command;
+      if (sqlFile === 'data.sql') {
+        // Para dados, usar single-transaction
+        command = `psql "${databaseUrl}" -v ON_ERROR_STOP=1 --single-transaction -f "${filePath}"`;
+      } else {
+        // Para roles e schema, usar ON_ERROR_STOP
+        command = `psql "${databaseUrl}" -v ON_ERROR_STOP=1 -f "${filePath}"`;
+      }
+      
+      const { stdout, stderr } = await runCommand(command);
+      
+      if (stderr && !stderr.includes('NOTICE')) {
+        console.log(chalk.yellow(`⚠️ Avisos em ${sqlFile}: ${stderr}`));
+      }
+      
+      console.log(chalk.green(`✅ ${sqlFile} executado com sucesso`));
+      
+    } catch (error) {
+      throw new Error(`Falha ao executar ${sqlFile}: ${error.message}`);
+    }
   }
 }
 
-module.exports = restoreCommand;
+module.exports = restoreCommand;

package/src/index.js

@@ -10,7 +10,6 @@ const chalk = require('chalk');
 // Exportar comandos
 const backupCommand = require('./commands/backup');
 const restoreCommand = require('./commands/restore');
-const secretsCommand = require('./commands/secrets');
 const functionsCommand = require('./commands/functions');
 const checkCommand = require('./commands/check');
 const configCommand = require('./commands/config');
@@ -91,33 +90,26 @@ function showQuickHelp() {
 🚀 COMANDOS PRINCIPAIS:
 
 📊 Backup completo:
-   smoonb backup                    # Usa projectId da configuração
-   smoonb backup --project-id <id>  # Especifica projectId
+   npx smoonb backup                    # Usa configuração do .smoonbrc
 
 🔄 Restauração completa:
-   smoonb restore --backup-dir <dir>                    # Usa projectId da configuração
-   smoonb restore --project-id <id> --backup-dir <dir>  # Especifica projectId
-
-🔐 Gerenciamento de secrets:
-   smoonb secrets export
-   smoonb secrets import
+   npx smoonb restore --backup-dir <dir>  # Restaura backup usando psql
 
 ⚡ Edge Functions:
-   smoonb functions push
-   smoonb functions list
+   npx smoonb functions list
+   npx smoonb functions push
 
 🔍 Verificação pós-restore:
-   smoonb check                    # Usa projectId da configuração
-   smoonb check --project-id <id>  # Especifica projectId
+   npx smoonb check                     # Verifica integridade do projeto
 
 ⚙️  Configuração:
-   smoonb config --init           # Criar arquivo de configuração
-   smoonb config --show           # Mostrar configuração atual
+   npx smoonb config --init             # Criar arquivo de configuração
+   npx smoonb config --show             # Mostrar configuração atual
 
 📋 CONFIGURAÇÃO AUTOMÁTICA:
-   smoonb config --init           # Cria ~/.smoonbrc com projectId, URLs, etc.
+   npx smoonb config --init       # Cria .smoonbrc com projectId, URLs, etc.
    # Edite o arquivo com suas credenciais Supabase
-   smoonb backup                  # Funciona sem --project-id!
+   npx smoonb backup              # Funciona automaticamente!
 
 📝 EXEMPLO DE CONFIGURAÇÃO (.smoonbrc):
    {
@@ -131,9 +123,9 @@ function showQuickHelp() {
    }
 
 🔧 COMO CONFIGURAR:
-   1. smoonb config --init
-   2. Edite ~/.smoonbrc com suas credenciais
-   3. smoonb backup (funciona automaticamente!)
+   1. npx smoonb config --init
+   2. Edite .smoonbrc com suas credenciais
+   3. npx smoonb backup (funciona automaticamente!)
 `));
 }
 
@@ -270,7 +262,6 @@ module.exports = {
   commands: {
     backup: backupCommand,
     restore: restoreCommand,
-    secrets: secretsCommand,
     functions: functionsCommand,
     check: checkCommand,
     config: configCommand