smoonb 0.0.69 → 0.0.71

package/README.md

@@ -23,7 +23,7 @@ O smoonb faz backup completo de todos os componentes do seu projeto Supabase:
 - ✅ **Custom Roles** (roles personalizados do PostgreSQL)
 - ✅ **Edge Functions** (download automático do servidor)
 - ✅ **Auth Settings** (configurações de autenticação via Management API)
-- ✅ **Storage Buckets** (metadados e configurações via Management API)
+- ✅ **Storage Buckets** (backup completo: metadados, configurações e todos os arquivos via Management API + Supabase Client, cria ZIP no padrão do Dashboard)
 - ✅ **Realtime Settings** (7 parâmetros capturados interativamente)
 - ✅ **Supabase .temp** (arquivos temporários do Supabase CLI)
 - ✅ **Migrations** (todas as migrations do projeto via `supabase migration fetch`)
@@ -169,7 +169,7 @@ npx smoonb backup
 4. **Backup do .env.local** - Cria backup automático antes de alterações
 5. **Seleção de Componentes** - Pergunta quais componentes incluir:
    - ⚡ Edge Functions (explicação sobre reset de link e download)
-   - 📦 Storage (explicação sobre metadados)
+   - 📦 Storage (explicação sobre backup completo: download de arquivos + ZIP no padrão do Dashboard)
    - 🔐 Auth Settings (explicação sobre configurações)
    - 🔄 Realtime Settings (explicação sobre captura interativa de 7 parâmetros)
    - 🗑️ Opções de limpeza (functions, .temp, migrations após backup)
@@ -181,7 +181,7 @@ npx smoonb backup
    - 🔧 3/10 - Backup Database Extensions and Settings
    - 🔐 4/10 - Backup Auth Settings (se selecionado)
    - 🔄 5/10 - Backup Realtime Settings (se selecionado) - 7 parâmetros capturados interativamente
-   - 📦 6/10 - Backup Storage (se selecionado)
+   - 📦 6/10 - Backup Storage (se selecionado) - Download completo de arquivos + ZIP no padrão do Dashboard
    - 👥 7/10 - Backup Custom Roles
    - ⚡ 8/10 - Backup Edge Functions (se selecionado)
    - 📁 9/10 - Backup Supabase .temp (se selecionado)
@@ -199,6 +199,11 @@ backups/backup-2025-10-31-09-37-54/
 ├── auth-settings.json             # Configurações de Auth
 ├── realtime-settings.json         # Configurações de Realtime
 ├── storage/                       # Metadados de Storage
+│   └── [bucket-name].json         # Metadados de cada bucket
+├── [project-id].storage.zip       # Backup completo de Storage (padrão Dashboard)
+├── storage_temp/                  # Estrutura temporária (opcional, pode ser removida)
+│   └── [project-id]/              # Estrutura de arquivos baixados
+│       └── [bucket-name]/        # Arquivos de cada bucket
 ├── edge-functions/                # Edge Functions baixadas
 │   └── [nome-da-function]/
 ├── supabase-temp/                 # Arquivos .temp do Supabase CLI
@@ -247,7 +252,7 @@ npx smoonb restore --file "backup.backup.gz" --storage "meu-projeto.storage.zip"
     - 📊 Database - Restaura via `psql` (suporta `.backup.gz` e `.backup`)
     - ⚡ Edge Functions - Copia e faz deploy no projeto destino
     - 🔐 Auth Settings - Exibe configurações para aplicação manual
-    - 📦 Storage - Exibe informações para migração manual
+    - 📦 Storage - Restaura buckets e arquivos do ZIP (se disponível) ou exibe informações para migração manual
     - 🔧 Database Settings - Restaura extensões e configurações via SQL
     - 🔄 Realtime Settings - Exibe configurações para aplicação manual
 
@@ -432,7 +437,17 @@ restore/
 - **Reset de Link**: Garante link limpo com o projeto
 - **Backup Completo**: Todas as migrations do servidor
 
-#### Auth, Storage, Realtime
+#### Storage
+- **Backup Completo**: Download de todos os arquivos de todos os buckets
+- **Estrutura Temporária**: Cria `storage_temp/project-id/bucket-name/arquivos...` dentro do backupDir
+- **ZIP no Padrão Dashboard**: Cria `{project-id}.storage.zip` com estrutura `project-id/bucket-name/arquivos...`
+- **Compatível com Restore**: O ZIP criado é compatível com o processo de restore (mesmo formato do Dashboard)
+- **Pergunta Interativa**: Após criar o ZIP, pergunta se deseja limpar a estrutura temporária
+- **Fallback**: Se não houver credenciais do Supabase, faz backup apenas de metadados
+- **Management API**: Usa Personal Access Token para listar buckets e objetos
+- **Supabase Client**: Usa Service Role Key para download de arquivos
+
+#### Auth, Realtime
 - **Management API**: Usa Personal Access Token
 - **JSON Export**: Configurações exportadas como JSON
 - **Realtime Settings**: Captura interativa de 7 parâmetros:
@@ -460,7 +475,8 @@ restore/
 
 #### Outros Componentes
 - **Database Settings**: Restaura via SQL
-- **Auth/Storage/Realtime**: Exibe informações para configuração manual no Dashboard
+- **Storage**: Restaura buckets e arquivos do ZIP (se disponível) ou exibe informações para configuração manual
+- **Auth/Realtime**: Exibe informações para configuração manual no Dashboard
 
 ### Multiplataforma
 
@@ -495,10 +511,10 @@ npx smoonb restore
 # 6. Verificar integridade
 npx smoonb check
 
-# 7. Aplicar configurações manuais
+# 7. Aplicar configurações manuais (se necessário)
 # - Auth Settings: Dashboard → Authentication → Settings
-# - Storage: Dashboard → Storage → Buckets
 # - Realtime: Dashboard → Database → Replication
+# Nota: Storage é restaurado automaticamente do ZIP se disponível
 ```
 
 ## 🎨 Experiência do Usuário

package/package.json

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

package/src/commands/backup/index.js

@@ -119,6 +119,8 @@ module.exports = async (options) => {
     const projectId = getValue('SUPABASE_PROJECT_ID');
     const accessToken = getValue('SUPABASE_ACCESS_TOKEN');
     const databaseUrl = getValue('SUPABASE_DB_URL');
+    const supabaseUrl = getValue('NEXT_PUBLIC_SUPABASE_URL');
+    const supabaseServiceKey = getValue('SUPABASE_SERVICE_ROLE_KEY');
 
     if (!databaseUrl) {
       console.log(chalk.red('❌ DATABASE_URL NÃO CONFIGURADA'));
@@ -187,6 +189,8 @@ module.exports = async (options) => {
       projectId,
       accessToken,
       databaseUrl,
+      supabaseUrl,
+      supabaseServiceKey,
       backupDir: finalBackupDir,
       outputDir: resolvedOutputDir,
       options: { ...options, flags },
@@ -326,7 +330,11 @@ module.exports = async (options) => {
     
     if (flags?.includeStorage && manifest.components.storage) {
       const storageResult = manifest.components.storage;
-      console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API`));
+      if (storageResult.zipFile) {
+        console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets, ${storageResult.totalFiles || 0} arquivo(s) baixado(s), ZIP: ${storageResult.zipFile} (${storageResult.zipSizeMB || 0} MB)`));
+      } else {
+        console.log(chalk.green(`📦 Storage: ${storageResult.buckets?.length || 0} buckets verificados via API (apenas metadados)`));
+      }
     }
     
     console.log(chalk.green(`👥 Custom Roles: ${rolesResult.roles?.length || 0} roles exportados via SQL`));

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

@@ -1,11 +1,16 @@
 const chalk = require('chalk');
 const path = require('path');
+const fs = require('fs').promises;
+const AdmZip = require('adm-zip');
+const { createClient } = require('@supabase/supabase-js');
 const { ensureDir, writeJson } = require('../../../utils/fsx');
+const { confirm } = require('../../../utils/prompt');
 
 /**
  * Etapa 6: Backup Storage via Supabase API
+ * Agora faz backup completo: metadados + download de todos os arquivos + ZIP no padrão do Dashboard
  */
-module.exports = async ({ projectId, accessToken, backupDir }) => {
+module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supabaseServiceKey }) => {
   try {
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
@@ -37,7 +42,25 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
 
     console.log(chalk.white(`   - Encontrados ${buckets.length} buckets`));
 
+    // Validar credenciais do Supabase para download de arquivos
+    if (!supabaseUrl || !supabaseServiceKey) {
+      console.log(chalk.yellow('   ⚠️  Credenciais do Supabase não disponíveis. Fazendo backup apenas de metadados...'));
+      return await backupMetadataOnly(buckets, storageDir, projectId, accessToken);
+    }
+
+    // Criar cliente Supabase para download de arquivos
+    const supabase = createClient(supabaseUrl, supabaseServiceKey);
+
+    // Criar estrutura temporária para armazenar arquivos baixados
+    const tempStorageDir = path.join(backupDir, 'storage_temp');
+    await ensureDir(tempStorageDir);
+    
+    // Criar estrutura: storage_temp/project-id/bucket-name/arquivos...
+    const projectStorageDir = path.join(tempStorageDir, projectId);
+    await ensureDir(projectStorageDir);
+
     const processedBuckets = [];
+    let totalFilesDownloaded = 0;
 
     for (const bucket of buckets || []) {
       try {
@@ -69,22 +92,222 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
         const bucketPath = path.join(storageDir, `${bucket.name}.json`);
         await writeJson(bucketPath, bucketInfo);
 
+        // Baixar todos os arquivos do bucket
+        const bucketDir = path.join(projectStorageDir, bucket.name);
+        await ensureDir(bucketDir);
+        
+        // Listar todos os arquivos recursivamente usando Supabase client
+        console.log(chalk.white(`     - Listando arquivos do bucket ${bucket.name}...`));
+        const allFiles = await listAllFilesRecursively(supabase, bucket.name, '');
+        
+        let filesDownloaded = 0;
+        if (allFiles.length > 0) {
+          console.log(chalk.white(`     - Baixando ${allFiles.length} arquivo(s) do bucket ${bucket.name}...`));
+          
+          for (const filePath of allFiles) {
+            try {
+              // Baixar arquivo do Storage
+              const { data: fileData, error: downloadError } = await supabase.storage
+                .from(bucket.name)
+                .download(filePath);
+
+              if (downloadError) {
+                console.log(chalk.yellow(`       ⚠️  Erro ao baixar ${filePath}: ${downloadError.message}`));
+                continue;
+              }
+
+              // Criar estrutura de pastas local se necessário
+              const localFilePath = path.join(bucketDir, filePath);
+              const localFileDir = path.dirname(localFilePath);
+              await ensureDir(localFileDir);
+
+              // Salvar arquivo localmente
+              const arrayBuffer = await fileData.arrayBuffer();
+              const buffer = Buffer.from(arrayBuffer);
+              await fs.writeFile(localFilePath, buffer);
+              filesDownloaded++;
+
+              // Mostrar progresso a cada 10 arquivos ou se for o último
+              if (filesDownloaded % 10 === 0 || filesDownloaded === allFiles.length) {
+                console.log(chalk.white(`       - Baixados ${filesDownloaded}/${allFiles.length} arquivo(s)...`));
+              }
+            } catch (fileError) {
+              console.log(chalk.yellow(`       ⚠️  Erro ao processar arquivo ${filePath}: ${fileError.message}`));
+            }
+          }
+        }
+
+        totalFilesDownloaded += filesDownloaded;
         processedBuckets.push({
           name: bucket.name,
-          objectCount: objects?.length || 0
+          objectCount: objects?.length || 0,
+          filesDownloaded: filesDownloaded,
+          totalFiles: allFiles.length
         });
 
-        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${objects?.length || 0} objetos`));
+        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${filesDownloaded}/${allFiles.length} arquivo(s) baixado(s)`));
       } catch (error) {
         console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
       }
     }
 
-    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets`));
-    return { success: true, buckets: processedBuckets };
+    // Criar ZIP no padrão do Dashboard: {project-id}.storage.zip
+    console.log(chalk.white('\n   - Criando arquivo ZIP no padrão do Dashboard...'));
+    const zipFileName = `${projectId}.storage.zip`;
+    const zipFilePath = path.join(backupDir, zipFileName);
+    
+    const zip = new AdmZip();
+    
+    // Adicionar toda a estrutura de pastas ao ZIP
+    // Estrutura: project-id/bucket-name/arquivos...
+    await addDirectoryToZip(zip, projectStorageDir, projectId);
+    
+    // Salvar ZIP
+    zip.writeZip(zipFilePath);
+    const zipStats = await fs.stat(zipFilePath);
+    const zipSizeMB = (zipStats.size / (1024 * 1024)).toFixed(2);
+    
+    console.log(chalk.green(`   ✅ Arquivo ZIP criado: ${zipFileName} (${zipSizeMB} MB)`));
+
+    // Perguntar ao usuário se deseja limpar a estrutura temporária
+    const tempDirName = path.basename(tempStorageDir);
+    const shouldCleanup = await confirm(`   Deseja limpar ${tempDirName} após o backup`, false);
+    
+    if (shouldCleanup) {
+      console.log(chalk.white(`   - Limpando estrutura temporária...`));
+      try {
+        await fs.rm(tempStorageDir, { recursive: true, force: true });
+        console.log(chalk.green(`   ✅ Estrutura temporária removida`));
+      } catch (cleanupError) {
+        console.log(chalk.yellow(`   ⚠️  Erro ao limpar estrutura temporária: ${cleanupError.message}`));
+      }
+    } else {
+      console.log(chalk.white(`   ℹ️  Estrutura temporária mantida em: ${path.relative(process.cwd(), tempStorageDir)}`));
+    }
+
+    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets, ${totalFilesDownloaded} arquivo(s) baixado(s)`));
+    return { 
+      success: true, 
+      buckets: processedBuckets,
+      zipFile: zipFileName,
+      zipSizeMB: zipSizeMB,
+      totalFiles: totalFilesDownloaded,
+      tempDirCleaned: shouldCleanup
+    };
   } catch (error) {
     console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
     return { success: false, buckets: [] };
   }
 };
 
+/**
+ * Backup apenas de metadados (fallback quando não há credenciais do Supabase)
+ */
+async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
+  const processedBuckets = [];
+
+  for (const bucket of buckets || []) {
+    try {
+      console.log(chalk.white(`   - Processando bucket: ${bucket.name}`));
+      
+      const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {
+        headers: { 
+          'Authorization': `Bearer ${accessToken}`,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      let objects = [];
+      if (objectsResponse.ok) {
+        objects = await objectsResponse.json();
+      }
+
+      const bucketInfo = {
+        id: bucket.id,
+        name: bucket.name,
+        public: bucket.public,
+        file_size_limit: bucket.file_size_limit,
+        allowed_mime_types: bucket.allowed_mime_types,
+        objects: objects || []
+      };
+
+      const bucketPath = path.join(storageDir, `${bucket.name}.json`);
+      await writeJson(bucketPath, bucketInfo);
+
+      processedBuckets.push({
+        name: bucket.name,
+        objectCount: objects?.length || 0
+      });
+
+      console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${objects?.length || 0} objetos`));
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
+    }
+  }
+
+  console.log(chalk.green(`✅ Storage backupado (apenas metadados): ${processedBuckets.length} buckets`));
+  return { success: true, buckets: processedBuckets };
+}
+
+/**
+ * Lista todos os arquivos recursivamente de um bucket do Storage
+ */
+async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
+  const allFiles = [];
+  
+  try {
+    // Listar arquivos e pastas no caminho atual
+    const { data: items, error } = await supabase.storage
+      .from(bucketName)
+      .list(folderPath, {
+        limit: 1000,
+        sortBy: { column: 'name', order: 'asc' }
+      });
+
+    if (error) {
+      console.log(chalk.yellow(`       ⚠️  Erro ao listar ${folderPath || 'raiz'}: ${error.message}`));
+      return allFiles;
+    }
+
+    if (!items || items.length === 0) {
+      return allFiles;
+    }
+
+    for (const item of items) {
+      const itemPath = folderPath ? `${folderPath}/${item.name}` : item.name;
+      
+      if (item.id === null) {
+        // É uma pasta, listar recursivamente
+        const subFiles = await listAllFilesRecursively(supabase, bucketName, itemPath);
+        allFiles.push(...subFiles);
+      } else {
+        // É um arquivo
+        allFiles.push(itemPath);
+      }
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`       ⚠️  Erro ao processar ${folderPath || 'raiz'}: ${error.message}`));
+  }
+
+  return allFiles;
+}
+
+/**
+ * Adiciona um diretório recursivamente ao ZIP mantendo a estrutura de pastas
+ */
+async function addDirectoryToZip(zip, dirPath, basePath = '') {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const zipPath = basePath ? `${basePath}/${entry.name}` : entry.name;
+    
+    if (entry.isDirectory()) {
+      await addDirectoryToZip(zip, fullPath, zipPath);
+    } else {
+      const fileContent = await fs.readFile(fullPath);
+      zip.addFile(zipPath, fileContent);
+    }
+  }
+}
+

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

@@ -100,6 +100,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     // 3. Selecionar o primeiro arquivo .storage.zip encontrado
     const storageZipFile = path.join(backupPath, storageZipFiles[0]);
+    const storageZipBaseName = path.basename(storageZipFiles[0], '.storage.zip');
     console.log(chalk.white(`   - Arquivo de storage encontrado: ${storageZipFiles[0]}`));
     
     // 4. Validar credenciais do projeto destino
@@ -155,17 +156,30 @@ module.exports = async ({ backupPath, targetProject }) => {
       const firstItem = extractedContents[0];
       const firstItemPath = path.join(extractDir, firstItem);
       const firstItemStats = await fs.stat(firstItemPath);
-      
+
       if (firstItemStats.isDirectory()) {
         // Verificar se o nome da pasta raiz corresponde ao Project ID antigo OU novo
-        const isProjectId = 
-          (sourceProjectId && firstItem === sourceProjectId) || 
-          (firstItem === targetProject.targetProjectId);
-        
+        const matchesSourceProjectId = sourceProjectId && firstItem === sourceProjectId;
+        const matchesTargetProjectId = firstItem === targetProject.targetProjectId;
+        const matchesZipFileName = firstItem === storageZipBaseName;
+        const matchesProjectIdPattern = isLikelyProjectId(firstItem);
+
+        const isProjectId =
+          matchesSourceProjectId ||
+          matchesTargetProjectId ||
+          matchesZipFileName ||
+          matchesProjectIdPattern;
+
         if (isProjectId) {
           // A pasta raiz é um wrapper do Project ID - SEMPRE buscar buckets nas subpastas
           rootDir = firstItem;
-          console.log(chalk.white(`   - Detectada pasta raiz com Project ID: ${firstItem}`));
+          const reasons = [];
+          if (matchesSourceProjectId) reasons.push('manifest');
+          if (matchesTargetProjectId) reasons.push('projeto destino');
+          if (matchesZipFileName) reasons.push('nome do arquivo ZIP');
+          if (matchesProjectIdPattern) reasons.push('formato de Project ID');
+          const reasonText = reasons.length ? ` (${reasons.join(', ')})` : '';
+          console.log(chalk.white(`   - Detectada pasta raiz com Project ID: ${firstItem}${reasonText}`));
           console.log(chalk.white(`   - Buscando buckets nas subpastas...`));
         }
       }
@@ -551,3 +565,12 @@ function getContentType(fileName) {
   
   return contentTypes[ext] || 'application/octet-stream';
 }
+
+function isLikelyProjectId(name) {
+  if (!name || typeof name !== 'string') {
+    return false;
+  }
+
+  // Project IDs do Supabase são normalmente strings de 20 caracteres alfanuméricos minúsculos
+  return /^[a-z0-9]{20}$/.test(name);
+}