smoonb 0.0.44 → 0.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,
@@ -12,7 +12,10 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "node bin/smoonb.js",
     "preinstall": "node -e \"if(process.env.npm_config_global) { console.error('\\n❌ SMOONB NÃO DEVE SER INSTALADO GLOBALMENTE!\\n\\n📋 Para usar o smoonb, instale localmente no seu projeto:\\n   npm install smoonb\\n\\n💡 Depois execute com:\\n   npx smoonb backup\\n\\n🚫 Instalação global cancelada!\\n'); process.exit(1); }\"",
-    "postinstall": "echo '\\n✅ smoonb instalado com sucesso!\\n💡 Execute: npx smoonb backup\\n📖 Documentação: https://github.com/almmello/smoonb\\n'"
+    "postinstall": "echo '\\n✅ smoonb instalado com sucesso!\\n💡 Execute: npx smoonb backup\\n📖 Documentação: https://github.com/almmello/smoonb\\n'",
+    "lint": "eslint . --ext .js",
+    "lint:fix": "eslint . --ext .js --fix",
+    "build": "npm run lint"
   },
   "keywords": [
     "supabase",
@@ -36,6 +39,9 @@
     "inquirer": "^8.2.7"
   },
   "type": "commonjs",
+  "devDependencies": {
+    "eslint": "^9.38.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/almmello/smoonb.git"
@@ -44,4 +50,11 @@
     "url": "https://github.com/almmello/smoonb/issues"
   },
   "homepage": "https://github.com/almmello/smoonb#readme"
+  ,
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE.md"
+  ]
 }

package/src/commands/backup.js

@@ -9,6 +9,9 @@ const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
 const { canPerformCompleteBackup, getDockerVersion } = require('../utils/docker');
 const { captureRealtimeSettings } = require('../utils/realtime-settings');
+const { readEnvFile, writeEnvFile, backupEnvFile } = require('../utils/env');
+const { saveEnvMap } = require('../utils/envMap');
+const { mapEnvVariablesInteractively, askComponentsFlags } = require('../interactive/envMapper');
 
 const execAsync = promisify(exec);
 
@@ -17,16 +20,82 @@ module.exports = async (options) => {
   showBetaBanner();
   
   try {
-    // Carregar e validar configuração
-    const config = await readConfig();
+    // 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');
 
     // Validação adicional para pré-requisitos obrigatórios
-    if (!config.supabase.databaseUrl) {
+    // 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 (prioriza .env.local mapeado depois, por ora usa default)
+    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 databaseUrl no .smoonbrc'));
+      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:'));
@@ -36,12 +105,12 @@ module.exports = async (options) => {
       process.exit(1);
     }
 
-    if (!config.supabase.accessToken) {
+    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 accessToken no .smoonbrc'));
+      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:'));
@@ -53,7 +122,7 @@ module.exports = async (options) => {
       process.exit(1);
     }
 
-    console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${config.supabase.projectId}`));
+    console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${projectId}`));
     console.log(chalk.gray(`🔍 Verificando dependências Docker...`));
 
     // Verificar se é possível fazer backup completo via Docker
@@ -65,7 +134,9 @@ module.exports = async (options) => {
       console.log('');
       
       // Proceder com backup completo via Docker
-      return await performFullBackup(config, options);
+      // Flags de componentes (não afetam Database)
+      const flags = await askComponentsFlags();
+      return await performFullBackup({ projectId, accessToken, databaseUrl }, { ...options, flags, backupDir: finalBackupDir, outputDir: resolvedOutputDir });
     } else {
       // Mostrar mensagens educativas e encerrar elegantemente
       showDockerMessagesAndExit(backupCapability.reason);
@@ -78,28 +149,17 @@ module.exports = async (options) => {
 };
 
 // Função para backup completo via Docker
-async function performFullBackup(config, options) {
-  // Resolver diretório de saída
-  const outputDir = options.output || config.backup.outputDir;
-  
-  // Criar diretório de backup com timestamp humanizado
-  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');
-  
-  const backupDir = path.join(outputDir, `backup-${year}-${month}-${day}-${hour}-${minute}-${second}`);
-  await ensureDir(backupDir);
+async function performFullBackup(envCfg, options) {
+  const { projectId, accessToken, databaseUrl } = envCfg;
+  const outputDir = options.outputDir;
+  const backupDir = options.backupDir;
 
   console.log(chalk.blue(`📁 Diretório: ${backupDir}`));
   console.log(chalk.gray(`🐳 Backup via Docker Desktop`));
 
   const manifest = {
     created_at: new Date().toISOString(),
-    project_id: config.supabase.projectId,
+    project_id: projectId,
     smoonb_version: require('../../package.json').version,
     backup_type: 'pg_dumpall_docker_dashboard_compatible',
     docker_version: await getDockerVersion(),
@@ -109,12 +169,12 @@ async function performFullBackup(config, options) {
 
   // 1. Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
   console.log(chalk.blue('\n📊 1/8 - Backup da Database PostgreSQL via pg_dumpall Docker...'));
-  const databaseResult = await backupDatabase(config.supabase.projectId, backupDir);
+  const databaseResult = await backupDatabase(databaseUrl, backupDir);
   manifest.components.database = databaseResult;
 
   // 1.5. Backup Database Separado (SQL files para troubleshooting)
   console.log(chalk.blue('\n📊 1.5/8 - Backup da Database PostgreSQL (arquivos SQL separados)...'));
-  const dbSeparatedResult = await backupDatabaseSeparated(config.supabase.projectId, backupDir);
+  const dbSeparatedResult = await backupDatabaseSeparated(databaseUrl, backupDir, accessToken);
   manifest.components.database_separated = {
     success: dbSeparatedResult.success,
     method: 'supabase-cli',
@@ -123,34 +183,42 @@ async function performFullBackup(config, options) {
   };
 
   // 2. Backup Edge Functions via Docker
-  console.log(chalk.blue('\n⚡ 2/8 - Backup das Edge Functions via Docker...'));
-  const functionsResult = await backupEdgeFunctionsWithDocker(config.supabase.projectId, config.supabase.accessToken, backupDir);
-  manifest.components.edge_functions = functionsResult;
+  if (options.flags?.includeFunctions) {
+    console.log(chalk.blue('\n⚡ 2/8 - Backup das Edge Functions via Docker...'));
+    const functionsResult = await backupEdgeFunctionsWithDocker(projectId, accessToken, backupDir);
+    manifest.components.edge_functions = functionsResult;
+  }
 
   // 3. Backup Auth Settings via API
-  console.log(chalk.blue('\n🔐 3/8 - Backup das Auth Settings via API...'));
-  const authResult = await backupAuthSettings(config.supabase.projectId, config.supabase.accessToken, backupDir);
-  manifest.components.auth_settings = authResult;
+  if (options.flags?.includeAuth) {
+    console.log(chalk.blue('\n🔐 3/8 - Backup das Auth Settings via API...'));
+    const authResult = await backupAuthSettings(projectId, accessToken, backupDir);
+    manifest.components.auth_settings = authResult;
+  }
 
   // 4. Backup Storage via API
-  console.log(chalk.blue('\n📦 4/8 - Backup do Storage via API...'));
-  const storageResult = await backupStorage(config.supabase.projectId, config.supabase.accessToken, backupDir);
-  manifest.components.storage = storageResult;
+  if (options.flags?.includeStorage) {
+    console.log(chalk.blue('\n📦 4/8 - Backup do Storage via API...'));
+    const storageResult = await backupStorage(projectId, accessToken, backupDir);
+    manifest.components.storage = storageResult;
+  }
 
   // 5. Backup Custom Roles via SQL
   console.log(chalk.blue('\n👥 5/8 - Backup dos Custom Roles via SQL...'));
-  const rolesResult = await backupCustomRoles(config.supabase.databaseUrl, backupDir);
+  const rolesResult = await backupCustomRoles(databaseUrl, backupDir, accessToken);
   manifest.components.custom_roles = rolesResult;
 
   // 6. Backup das Database Extensions and Settings via SQL
   console.log(chalk.blue('\n🔧 6/8 - Backup das Database Extensions and Settings via SQL...'));
-  const databaseSettingsResult = await backupDatabaseSettings(config.supabase.projectId, backupDir);
+  const databaseSettingsResult = await backupDatabaseSettings(databaseUrl, projectId, backupDir);
   manifest.components.database_settings = databaseSettingsResult;
 
   // 7. Backup Realtime Settings via Captura Interativa
-  console.log(chalk.blue('\n🔄 7/8 - Backup das Realtime Settings via Captura Interativa...'));
-  const realtimeResult = await backupRealtimeSettings(config.supabase.projectId, backupDir, options.skipRealtime);
-  manifest.components.realtime = realtimeResult;
+  if (options.flags?.includeRealtime) {
+    console.log(chalk.blue('\n🔄 7/8 - Backup das Realtime Settings via Captura Interativa...'));
+    const realtimeResult = await backupRealtimeSettings(projectId, backupDir, options.skipRealtime);
+    manifest.components.realtime = realtimeResult;
+  }
 
   // Salvar manifest
   await writeJson(path.join(backupDir, 'backup-manifest.json'), manifest);
@@ -160,20 +228,50 @@ async function performFullBackup(config, options) {
   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`));
-  console.log(chalk.green(`⚡ Edge Functions: ${functionsResult.success_count || 0}/${functionsResult.functions_count || 0} functions baixadas via Docker`));
-  console.log(chalk.green(`🔐 Auth Settings: ${authResult.success ? 'Exportadas via API' : 'Falharam'}`));
-  console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API`));
+  if (options.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 (options.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 (options.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
-  let realtimeMessage = 'Falharam';
-  if (realtimeResult.success) {
-    if (options.skipRealtime) {
-      realtimeMessage = 'Configurações copiadas do backup anterior';
-    } else {
-      realtimeMessage = 'Configurações capturadas interativamente';
+  if (options.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}`));
   }
-  console.log(chalk.green(`🔄 Realtime: ${realtimeMessage}`));
+
+  // report.json
+  await writeJson(path.join(backupDir, 'report.json'), {
+    process: 'backup',
+    created_at: manifest.created_at,
+    project_id: manifest.project_id,
+    assets: {
+      env: path.join(backupDir, 'env', '.env.local'),
+      env_map: path.join(backupDir, 'env', 'env-map.json'),
+      manifest: path.join(backupDir, 'backup-manifest.json')
+    },
+    components: {
+      includeFunctions: !!options.flags?.includeFunctions,
+      includeStorage: !!options.flags?.includeStorage,
+      includeAuth: !!options.flags?.includeAuth,
+      includeRealtime: !!options.flags?.includeRealtime
+    }
+  });
 
   return { success: true, backupDir, manifest };
 }
@@ -240,16 +338,14 @@ function showDockerMessagesAndExit(reason) {
 }
 
 // Backup da database usando pg_dumpall via Docker (idêntico ao Supabase Dashboard)
-async function backupDatabase(projectId, backupDir) {
+async function backupDatabase(databaseUrl, backupDir) {
   try {
     console.log(chalk.gray('   - Criando backup completo via pg_dumpall...'));
     
     const { execSync } = require('child_process');
-    const config = await readConfig();
     
     // Extrair credenciais da databaseUrl
-    const dbUrl = config.supabase.databaseUrl;
-    const urlMatch = dbUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
     
     if (!urlMatch) {
       throw new Error('Database URL inválida');
@@ -309,14 +405,12 @@ async function backupDatabase(projectId, backupDir) {
 }
 
 // Backup da database usando arquivos SQL separados via Supabase CLI (para troubleshooting)
-async function backupDatabaseSeparated(projectId, backupDir) {
+async function backupDatabaseSeparated(databaseUrl, backupDir, accessToken) {
   try {
     console.log(chalk.gray('   - Criando backups SQL separados via Supabase CLI...'));
     
     const { execSync } = require('child_process');
-    const config = await readConfig();
-    
-    const dbUrl = config.supabase.databaseUrl;
+    const dbUrl = databaseUrl;
     const files = [];
     let totalSizeKB = 0;
     
@@ -325,7 +419,7 @@ async function backupDatabaseSeparated(projectId, backupDir) {
     const schemaFile = path.join(backupDir, 'schema.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`, { stdio: 'pipe' });
+      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 });
@@ -340,7 +434,7 @@ async function backupDatabaseSeparated(projectId, backupDir) {
     const dataFile = path.join(backupDir, 'data.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`, { stdio: 'pipe' });
+      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 });
@@ -355,7 +449,7 @@ async function backupDatabaseSeparated(projectId, backupDir) {
     const rolesFile = path.join(backupDir, 'roles.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`, { stdio: 'pipe' });
+      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 });
@@ -625,7 +719,7 @@ async function backupStorage(projectId, accessToken, backupDir) {
 }
 
 // Backup dos Custom Roles via Docker
-async function backupCustomRoles(databaseUrl, backupDir) {
+async function backupCustomRoles(databaseUrl, backupDir, accessToken) {
   try {
     console.log(chalk.gray('   - Exportando Custom Roles via Docker...'));
     
@@ -633,7 +727,7 @@ async function backupCustomRoles(databaseUrl, backupDir) {
     
     try {
       // ✅ Usar Supabase CLI via Docker para roles
-      await execAsync(`supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`);
+      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);
@@ -652,16 +746,14 @@ async function backupCustomRoles(databaseUrl, backupDir) {
 }
 
 // Backup das Database Extensions and Settings via SQL
-async function backupDatabaseSettings(projectId, backupDir) {
+async function backupDatabaseSettings(databaseUrl, projectId, backupDir) {
   try {
     console.log(chalk.gray('   - Capturando Database Extensions and Settings...'));
     
     const { execSync } = require('child_process');
-    const config = await readConfig();
     
     // Extrair credenciais da databaseUrl
-    const dbUrl = config.supabase.databaseUrl;
-    const urlMatch = dbUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
     
     if (!urlMatch) {
       throw new Error('Database URL inválida');

package/src/commands/restore.js

@@ -4,18 +4,72 @@ const fs = require('fs');
 const { readConfig, getSourceProject, getTargetProject } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
 const inquirer = require('inquirer');
+const { readEnvFile, writeEnvFile, backupEnvFile } = require('../utils/env');
+const { saveEnvMap } = require('../utils/envMap');
+const { mapEnvVariablesInteractively } = require('../interactive/envMapper');
 
 module.exports = async (options) => {
   showBetaBanner();
   
   try {
-    const config = await readConfig();
-    const targetProject = getTargetProject(config);
-    
-    console.log(chalk.blue(`📁 Buscando backups em: ${config.backup.outputDir || './backups'}`));
+    // 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 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);
+    }
+
+    // Preparar diretório de processo restore-YYYY-...
+    const rootBackupsDir = path.join(process.cwd(), 'backups');
+    const now = new Date();
+    const ts = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,'0')}-${String(now.getDate()).padStart(2,'0')}-${String(now.getHours()).padStart(2,'0')}-${String(now.getMinutes()).padStart(2,'0')}-${String(now.getSeconds()).padStart(2,'0')}`;
+    const processDir = path.join(rootBackupsDir, `restore-${ts}`);
+    fs.mkdirSync(path.join(processDir, 'env'), { recursive: true });
+
+    // Backup do .env.local
+    const envPath = path.join(process.cwd(), '.env.local');
+    const envBackupPath = path.join(processDir, 'env', '.env.local');
+    await backupEnvFile(envPath, envBackupPath);
+    console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+
+    // Leitura e mapeamento interativo
+    const currentEnv = await readEnvFile(envPath);
+    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 { finalEnv, dePara } = await mapEnvVariablesInteractively(currentEnv, expectedKeys);
+    await writeEnvFile(envPath, finalEnv);
+    await saveEnvMap(dePara, path.join(processDir, 'env', 'env-map.json'));
+    console.log(chalk.green('✅ .env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.'));
+
+    // Resolver valores esperados a partir do de-para
+    function getValue(expectedKey) {
+      const clientKey = Object.keys(dePara).find(k => dePara[k] === expectedKey);
+      return clientKey ? finalEnv[clientKey] : '';
+    }
+
+    // Construir targetProject a partir do .env.local mapeado
+    const targetProject = {
+      targetProjectId: getValue('SUPABASE_PROJECT_ID'),
+      targetUrl: getValue('NEXT_PUBLIC_SUPABASE_URL'),
+      targetAnonKey: getValue('NEXT_PUBLIC_SUPABASE_ANON_KEY'),
+      targetServiceKey: getValue('SUPABASE_SERVICE_ROLE_KEY'),
+      targetDatabaseUrl: getValue('SUPABASE_DB_URL'),
+      targetAccessToken: getValue('SUPABASE_ACCESS_TOKEN')
+    };
+    
+    console.log(chalk.blue(`📁 Buscando backups em: ${getValue('SMOONB_OUTPUT_DIR') || './backups'}`));
     
     // 1. Listar backups válidos (.backup.gz)
-    const validBackups = await listValidBackups(config.backup.outputDir || './backups');
+    const validBackups = await listValidBackups(getValue('SMOONB_OUTPUT_DIR') || './backups');
     
     if (validBackups.length === 0) {
       console.error(chalk.red('❌ Nenhum backup válido encontrado'));
@@ -81,6 +135,26 @@ module.exports = async (options) => {
       await restoreRealtimeSettings(selectedBackup.path, targetProject);
     }
     
+    // report.json de restauração
+    const report = {
+      process: 'restore',
+      created_at: new Date().toISOString(),
+      target_project_id: targetProject.targetProjectId,
+      assets: {
+        env: path.join(processDir, 'env', '.env.local'),
+        env_map: path.join(processDir, 'env', 'env-map.json')
+      },
+      components: components,
+      notes: [
+        'supabase/functions limpo antes e depois do deploy (se Edge Functions selecionado)'
+      ]
+    };
+    try {
+      require('fs').writeFileSync(path.join(processDir, 'report.json'), JSON.stringify(report, null, 2));
+    } catch (e) {
+      // silencioso
+    }
+
     console.log(chalk.green('\n🎉 Restauração completa finalizada!'));
     
   } catch (error) {
@@ -187,7 +261,7 @@ async function askRestoreComponents(backupPath) {
   questions.push({
     type: 'confirm',
     name: 'restoreDatabase',
-    message: 'Deseja restaurar Database?',
+    message: 'Deseja restaurar Database (S/n):',
     default: true
   });
   
@@ -197,7 +271,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreEdgeFunctions',
-      message: 'Deseja restaurar Edge Functions?',
+      message: 'Deseja restaurar Edge Functions (S/n):',
       default: true
     });
   }
@@ -207,8 +281,8 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreAuthSettings',
-      message: 'Deseja restaurar Auth Settings (interativo)?',
-      default: true
+      message: 'Deseja restaurar Auth Settings (s/N):',
+      default: false
     });
   }
   
@@ -218,7 +292,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreStorage',
-      message: 'Deseja ver informações de Storage Buckets?',
+      message: 'Deseja ver informações de Storage Buckets (s/N):',
       default: false
     });
   }
@@ -230,7 +304,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreDatabaseSettings',
-      message: 'Deseja restaurar Database Extensions and Settings?',
+      message: 'Deseja restaurar Database Extensions and Settings (s/N):',
       default: false
     });
   }
@@ -240,8 +314,8 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreRealtimeSettings',
-      message: 'Deseja restaurar Realtime Settings (interativo)?',
-      default: true
+      message: 'Deseja restaurar Realtime Settings (s/N):',
+      default: false
     });
   }
   
@@ -401,17 +475,25 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
   console.log(chalk.blue('\n⚡ Restaurando Edge Functions...'));
   
   try {
+    const fs = require('fs').promises;
     const { execSync } = require('child_process');
     const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
     
-    if (!fs.existsSync(edgeFunctionsDir)) {
+    if (!await fs.access(edgeFunctionsDir).then(() => true).catch(() => false)) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
       return;
     }
     
-    const functions = fs.readdirSync(edgeFunctionsDir).filter(item => 
-      fs.statSync(path.join(edgeFunctionsDir, item)).isDirectory()
-    );
+    const items = await fs.readdir(edgeFunctionsDir);
+    const functions = [];
+    
+    for (const item of items) {
+      const itemPath = path.join(edgeFunctionsDir, item);
+      const stats = await fs.stat(itemPath);
+      if (stats.isDirectory()) {
+        functions.push(item);
+      }
+    }
     
     if (functions.length === 0) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
@@ -420,29 +502,57 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
     
     console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
     
-    // Link com projeto target
+    // ✅ COPIAR Edge Functions de backups/backup-XXX/edge-functions para supabase/functions
+    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
+    
+    // Criar diretório supabase/functions se não existir
+    await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+    
+    // Limpar supabase/functions antes de copiar
+    console.log(chalk.gray('   - Limpando supabase/functions...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+      await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+    } catch (cleanError) {
+      // Ignorar erro de limpeza se não existir
+    }
+    
+    // Copiar cada Edge Function para supabase/functions
+    for (const funcName of functions) {
+      const backupFuncPath = path.join(edgeFunctionsDir, funcName);
+      const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
+      
+      console.log(chalk.gray(`   - Copiando ${funcName} para supabase/functions...`));
+      
+      // Copiar recursivamente
+      await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
+    }
+    
     console.log(chalk.gray(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
     
+    // Linkar com o projeto destino
     try {
       execSync(`supabase link --project-ref ${targetProject.targetProjectId}`, {
         stdio: 'pipe',
-        encoding: 'utf8'
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
       });
     } catch (linkError) {
-      console.log(chalk.yellow(`   ⚠️  Link pode já existir, continuando...`));
+      console.log(chalk.yellow('   ⚠️  Link pode já existir, continuando...'));
     }
     
-    // Deploy de cada função
+    // Deploy das Edge Functions
     for (const funcName of functions) {
       console.log(chalk.gray(`   - Deployando ${funcName}...`));
       
       try {
-        const functionPath = path.join(edgeFunctionsDir, funcName);
-        
         execSync(`supabase functions deploy ${funcName}`, {
-          cwd: functionPath,
+          cwd: process.cwd(),
           stdio: 'pipe',
-          encoding: 'utf8'
+          encoding: 'utf8',
+          timeout: 120000,
+          env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
         });
         
         console.log(chalk.green(`   ✅ ${funcName} deployada com sucesso!`));
@@ -451,11 +561,41 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
       }
     }
     
+    // Limpar supabase/functions após deploy
+    console.log(chalk.gray('   - Limpando supabase/functions após deploy...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+    } catch (cleanError) {
+      // Ignorar erro de limpeza
+    }
+    
+    console.log(chalk.green('   ✅ Edge Functions restauradas com sucesso!'));
+    
   } catch (error) {
     console.error(chalk.red(`   ❌ Erro ao restaurar Edge Functions: ${error.message}`));
   }
 }
 
+// Função auxiliar para copiar diretório recursivamente
+async function copyDirectoryRecursive(src, dest) {
+  const fs = require('fs').promises;
+  
+  await fs.mkdir(dest, { recursive: true });
+  
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
 // Restaurar Storage Buckets (interativo - exibir informações)
 async function restoreStorageBuckets(backupPath, targetProject) {
   console.log(chalk.blue('\n📦 Restaurando Storage Buckets...'));

package/src/interactive/envMapper.js

@@ -0,0 +1,90 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+async function mapEnvVariablesInteractively(env, expectedKeys) {
+  const finalEnv = { ...env };
+  const dePara = {};
+
+  const allKeys = Object.keys(env);
+
+  for (const expected of expectedKeys) {
+    console.log(chalk.blue(`\n🔧 Mapeando variável: ${expected}`));
+
+    const choices = [
+      ...allKeys.map((k, idx) => ({ name: `${idx + 1}. ${k}`, value: k })),
+      new inquirer.Separator(),
+      { name: 'Adicionar nova chave com este nome', value: '__ADD_NEW__' }
+    ];
+
+    const { chosen } = await inquirer.prompt([{
+      type: 'list',
+      name: 'chosen',
+      message: `Selecione a chave correspondente para: ${expected}`,
+      choices
+    }]);
+
+    let clientKey = chosen;
+    if (chosen === '__ADD_NEW__') {
+      clientKey = expected;
+      if (Object.prototype.hasOwnProperty.call(finalEnv, clientKey)) {
+        // Evitar colisão: gerar sufixo incremental
+        let i = 2;
+        while (Object.prototype.hasOwnProperty.call(finalEnv, `${clientKey}_${i}`)) i++;
+        clientKey = `${clientKey}_${i}`;
+      }
+      finalEnv[clientKey] = '';
+    }
+
+    const currentValue = finalEnv[clientKey] ?? '';
+    const { isCorrect } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'isCorrect',
+      message: `Valor atual: ${currentValue || '(vazio)'} Este é o valor correto do projeto alvo? (S/n):`,
+      default: true
+    }]);
+
+    let valueToWrite = currentValue;
+    if (!isCorrect) {
+      const { newValue } = await inquirer.prompt([{
+        type: 'input',
+        name: 'newValue',
+        message: `Cole o novo valor para ${clientKey}:`
+      }]);
+      valueToWrite = newValue || '';
+    }
+
+    if (!valueToWrite) {
+      const { newValueRequired } = await inquirer.prompt([{
+        type: 'input',
+        name: 'newValueRequired',
+        message: `Valor obrigatório. Informe valor para ${clientKey}:`
+      }]);
+      valueToWrite = newValueRequired || '';
+    }
+
+    finalEnv[clientKey] = valueToWrite;
+    if (dePara[clientKey] && dePara[clientKey] !== expected) {
+      throw new Error(`Duplicidade de mapeamento detectada para ${clientKey}`);
+    }
+    dePara[clientKey] = expected;
+  }
+
+  return { finalEnv, dePara };
+}
+
+async function askComponentsFlags() {
+  const answers = await inquirer.prompt([
+    { type: 'confirm', name: 'includeFunctions', message: 'Deseja incluir Edge Functions (S/n):', default: true },
+    { type: 'confirm', name: 'includeStorage', message: 'Deseja incluir Storage (s/N):', default: false },
+    { type: 'confirm', name: 'includeAuth', message: 'Deseja incluir Auth (s/N):', default: false },
+    { type: 'confirm', name: 'includeRealtime', message: 'Deseja incluir Realtime (s/N):', default: false }
+  ]);
+  return answers;
+}
+
+module.exports = {
+  mapEnvVariablesInteractively,
+  askComponentsFlags
+};
+
+

package/src/utils/env.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const fsp = require('fs').promises;
+const path = require('path');
+
+function parseEnvContent(content) {
+  const lines = content.replace(/\r\n/g, '\n').split('\n');
+  const entries = {};
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIndex = line.indexOf('=');
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1);
+    // Remove optional quotes
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    entries[key] = value;
+  }
+  return entries;
+}
+
+function stringifyEnv(entries, existingContent) {
+  // Best-effort: keep existing comments and order; update or append keys
+  const existingLines = (existingContent || '').replace(/\r\n/g, '\n').split('\n');
+  const seen = new Set();
+  const resultLines = [];
+
+  for (let line of existingLines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) {
+      resultLines.push(line);
+      continue;
+    }
+    const eqIndex = line.indexOf('=');
+    const key = line.slice(0, eqIndex).trim();
+    if (Object.prototype.hasOwnProperty.call(entries, key)) {
+      const rawValue = entries[key] ?? '';
+      const needsQuote = /\s|[#]/.test(rawValue);
+      const safeValue = needsQuote ? `"${rawValue.replace(/"/g, '\\"')}"` : rawValue;
+      resultLines.push(`${key}=${safeValue}`);
+      seen.add(key);
+    } else {
+      resultLines.push(line);
+    }
+  }
+
+  for (const [key, value] of Object.entries(entries)) {
+    if (seen.has(key)) continue;
+    const rawValue = value ?? '';
+    const needsQuote = /\s|[#]/.test(rawValue);
+    const safeValue = needsQuote ? `"${rawValue.replace(/"/g, '\\"')}"` : rawValue;
+    resultLines.push(`${key}=${safeValue}`);
+  }
+
+  // Ensure trailing newline
+  let out = resultLines.join('\n');
+  if (!out.endsWith('\n')) out += '\n';
+  return out;
+}
+
+async function readEnvFile(filePath) {
+  try {
+    const content = await fsp.readFile(filePath, 'utf8');
+    return parseEnvContent(content);
+  } catch (e) {
+    if (e.code === 'ENOENT') return {};
+    throw e;
+  }
+}
+
+async function writeEnvFile(filePath, entries, options = {}) {
+  const dir = path.dirname(filePath);
+  await fsp.mkdir(dir, { recursive: true });
+  let existing = '';
+  try { existing = await fsp.readFile(filePath, 'utf8'); } catch {}
+  const content = stringifyEnv(entries, existing);
+  await fsp.writeFile(filePath, content, 'utf8');
+}
+
+async function backupEnvFile(srcPath, destPath) {
+  await fsp.mkdir(path.dirname(destPath), { recursive: true });
+  try {
+    await fsp.copyFile(srcPath, destPath);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      await fsp.writeFile(destPath, '', 'utf8');
+      return;
+    }
+    throw e;
+  }
+}
+
+function listEnvKeys(env) {
+  return Object.keys(env).sort();
+}
+
+module.exports = {
+  readEnvFile,
+  writeEnvFile,
+  backupEnvFile,
+  listEnvKeys
+};
+
+

package/src/utils/envMap.js

@@ -0,0 +1,25 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+async function loadEnvMap(filePath) {
+  if (!filePath) return {};
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch (e) {
+    return {};
+  }
+}
+
+async function saveEnvMap(map, destPath) {
+  await fs.mkdir(path.dirname(destPath), { recursive: true });
+  const json = JSON.stringify(map || {}, null, 2);
+  await fs.writeFile(destPath, json, 'utf8');
+}
+
+module.exports = {
+  loadEnvMap,
+  saveEnvMap
+};
+
+

package/src/utils/supabase.js

@@ -281,8 +281,8 @@ async function getProjectInfo(projectId) {
  * Listar tabelas da database
  */
 async function listTables() {
+  const client = getSupabaseClient();
   try {
-    const client = getSupabaseClient();
     
     // Usar RPC para listar tabelas
     const { data, error } = await client.rpc('get_tables');
@@ -315,8 +315,8 @@ async function listTables() {
  * Listar extensões instaladas
  */
 async function listExtensions() {
+  const client = getSupabaseClient();
   try {
-    const client = getSupabaseClient();
     
     // Usar RPC para listar extensões
     const { data, error } = await client.rpc('get_extensions');

package/.smoonbrc

@@ -1,29 +0,0 @@
-{
-  "supabase": {
-    "projectId": "xvfgdgdfgdfgdfgdfg",
-    "url": "https://dfgdfgdfgdfgdfgdfg.supabase.co",
-    "serviceKey": "sdfsdfsdfsdfsdfgyjyuiuyjyujuyjyujuyjyujuy",
-    "anonKey": "uyjyujyujyhmnbmbghjghjghghjghjghjghj",
-    "databaseUrl": "postgresql://postgres:ghjghjghjghjghjghjghj@db.sdfsdfsdfsdfsdfsdfsdfsdf.supabase.co:5432/postgres",
-    "accessToken": "your-personal-access-token-here"
-  },
-  "backup": {
-    "includeFunctions": true,
-    "includeStorage": true,
-    "includeAuth": true,
-    "includeRealtime": true,
-    "outputDir": "./backups",
-    "pgDumpPath": "C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe"
-  },
-  "restore": {
-    "verifyAfterRestore": true,
-    "targetProject": {
-      "targetProjectId": "target-project-id-here",
-      "targetUrl": "https://target-project.supabase.co",
-      "targetServiceKey": "target-service-key",
-      "targetAnonKey": "target-anon-key",
-      "targetDatabaseUrl": "postgresql://postgres:[password]@db.target-project.supabase.co:5432/postgres",
-      "targetAccessToken": "target-access-token"
-    }
-  }
-}

package/.smoonbrc.example

@@ -1,28 +0,0 @@
-{
-  "supabase": {
-    "projectId": "your-project-id-here",
-    "url": "https://your-project.supabase.co",
-    "serviceKey": "your-service-key-here",
-    "anonKey": "your-anon-key-here",
-    "databaseUrl": "postgresql://postgres:[password]@db.your-project.supabase.co:5432/postgres"
-  },
-  "backup": {
-    "includeFunctions": true,
-    "includeStorage": true,
-    "includeAuth": true,
-    "includeRealtime": true,
-    "outputDir": "./backups",
-    "pgDumpPath": "C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe"
-  },
-  "restore": {
-    "verifyAfterRestore": true,
-    "targetProject": {
-      "targetProjectId": "target-project-id-here",
-      "targetUrl": "https://target-project.supabase.co",
-      "targetServiceKey": "target-service-key",
-      "targetAnonKey": "target-anon-key",
-      "targetDatabaseUrl": "postgresql://postgres:[password]@db.target-project.supabase.co:5432/postgres",
-      "targetAccessToken": "target-access-token"
-    }
-  }
-}

package/backups/backup-2025-10-17T19-18-58-539Z/auth-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:18:58.553Z",
-  "projectId": "itrnlqsdfsdfsdf",
-  "providers": [],
-  "policies": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T19-18-58-539Z/backup-manifest.json

@@ -1,19 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:18:58.559Z",
-  "projectId": "itrnlqsdfsdfsdf",
-  "version": "0.1.0-beta",
-  "components": {
-    "database": false,
-    "functions": true,
-    "auth": true,
-    "storage": true,
-    "realtime": true
-  },
-  "files": {
-    "database": null,
-    "functions": "functions/",
-    "auth": "auth-config.json",
-    "storage": "storage/",
-    "realtime": "realtime-config.json"
-  }
-}

package/backups/backup-2025-10-17T19-18-58-539Z/functions/README.md

@@ -1,4 +0,0 @@
-# Edge Functions Backup
-
-Nenhuma Edge Function local foi encontrada.
-Use o Supabase CLI para fazer backup das functions remotas.

package/backups/backup-2025-10-17T19-18-58-539Z/realtime-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:18:58.558Z",
-  "projectId": "itrnlqsdfsdfsdf",
-  "enabled": false,
-  "channels": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T19-18-58-539Z/storage/storage-config.json

@@ -1,6 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:18:58.556Z",
-  "projectId": "itrnlqsdfsdfsdf",
-  "buckets": [],
-  "objects": []
-}

package/backups/backup-2025-10-17T19-52-20-211Z/auth-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:52:20.446Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "providers": [],
-  "policies": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T19-52-20-211Z/backup-manifest.json

@@ -1,19 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:52:20.452Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "version": "0.1.0-beta",
-  "components": {
-    "database": false,
-    "functions": true,
-    "auth": true,
-    "storage": true,
-    "realtime": true
-  },
-  "files": {
-    "database": null,
-    "functions": "functions/",
-    "auth": "auth-config.json",
-    "storage": "storage/",
-    "realtime": "realtime-config.json"
-  }
-}

package/backups/backup-2025-10-17T19-52-20-211Z/functions/README.md

@@ -1,4 +0,0 @@
-# Edge Functions Backup
-
-Nenhuma Edge Function local foi encontrada.
-Use o Supabase CLI para fazer backup das functions remotas.

package/backups/backup-2025-10-17T19-52-20-211Z/realtime-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:52:20.450Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "enabled": false,
-  "channels": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T19-52-20-211Z/storage/storage-config.json

@@ -1,6 +0,0 @@
-{
-  "timestamp": "2025-10-17T19:52:20.449Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "buckets": [],
-  "objects": []
-}

package/backups/backup-2025-10-17T20-38-13-188Z/auth-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T20:38:13.574Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "providers": [],
-  "policies": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T20-38-13-188Z/backup-manifest.json

@@ -1,19 +0,0 @@
-{
-  "timestamp": "2025-10-17T20:38:13.584Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "version": "0.1.0-beta",
-  "components": {
-    "database": false,
-    "functions": true,
-    "auth": true,
-    "storage": true,
-    "realtime": true
-  },
-  "files": {
-    "database": null,
-    "functions": "functions/",
-    "auth": "auth-config.json",
-    "storage": "storage/",
-    "realtime": "realtime-config.json"
-  }
-}

package/backups/backup-2025-10-17T20-38-13-188Z/functions/README.md

@@ -1,4 +0,0 @@
-# Edge Functions Backup
-
-Nenhuma Edge Function local foi encontrada.
-Use o Supabase CLI para fazer backup das functions remotas.

package/backups/backup-2025-10-17T20-38-13-188Z/realtime-config.json

@@ -1,7 +0,0 @@
-{
-  "timestamp": "2025-10-17T20:38:13.582Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "enabled": false,
-  "channels": [],
-  "settings": {}
-}

package/backups/backup-2025-10-17T20-38-13-188Z/storage/storage-config.json

@@ -1,6 +0,0 @@
-{
-  "timestamp": "2025-10-17T20:38:13.578Z",
-  "projectId": "xvfgdgdfgdfgdfgdfg",
-  "buckets": [],
-  "objects": []
-}