smoonb 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.0.6] - 2026-02-21
+
+### Changed
+
+- **Storage backup (step 6) — robustness and feedback:**
+  - Added `withTimeout` helper: each Storage `.list()` call times out after 30s; each file `.download()` times out after 2 minutes.
+  - Added `withRetry` helper: up to 3 attempts with exponential backoff (2s → 4s → 8s) on both listing and download failures.
+  - Inline progress during file listing: live `\r`-updated line shows the current folder being scanned and the running file count (`→ Scanning bucket/folder (N found)`). No more silent hangs.
+  - After listing completes, a summary line shows the total files found.
+  - Retry warnings show attempt number, failure reason and next retry delay.
+  - Download failures after all retries are counted as `filesSkipped` and reported in the bucket summary.
+  - Bucket summary now distinguishes between full success and partial success with skips.
+
+---
+
 ## [1.0.5] - 2026-02-21
 
 ### Added
@@ -49,5 +64,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ---
 
+[1.0.6]: https://github.com/almmello/smoonb/releases/tag/v1.0.6
 [1.0.5]: https://github.com/almmello/smoonb/releases/tag/v1.0.5
 [1.0.4]: https://github.com/almmello/smoonb/releases/tag/v1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Complete Supabase backup and migration tool. https://www.smoonb.com/#price",
   "preferGlobal": false,
   "preventGlobalInstall": true,

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

@@ -7,9 +7,52 @@ const { ensureDir, writeJson } = require('../../../utils/fsx');
 const { confirm } = require('../../../utils/prompt');
 const { t } = require('../../../i18n');
 
+const TIMEOUT_LIST_MS = 30_000;       // 30s por chamada de listagem
+const TIMEOUT_DOWNLOAD_MS = 360_000;  // 2min por download de arquivo
+const MAX_RETRIES = 7;
+const RETRY_BASE_DELAY_MS = 2_000;    // backoff: 2s → 4s → 8s
+
+/**
+ * Executa uma promise com timeout. Lança Error se o tempo esgotar.
+ * @param {Promise} promise
+ * @param {number} ms
+ * @returns {Promise}
+ */
+function withTimeout(promise, ms) {
+  let id;
+  const timer = new Promise((_, reject) => {
+    id = setTimeout(() => reject(new Error(`Timeout (${ms / 1000}s)`)), ms);
+  });
+  return Promise.race([promise, timer]).finally(() => clearTimeout(id));
+}
+
+/**
+ * Executa fn() com retry automático e backoff exponencial.
+ * @param {Function} fn - Fábrica de Promise (chamada a cada tentativa)
+ * @param {number} maxAttempts
+ * @param {number} baseDelayMs
+ * @param {Function} [onRetry] - Callback(attempt, max, err, delayMs)
+ */
+async function withRetry(fn, maxAttempts = MAX_RETRIES, baseDelayMs = RETRY_BASE_DELAY_MS, onRetry) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts) {
+        const delay = baseDelayMs * Math.pow(2, attempt - 1);
+        if (onRetry) onRetry(attempt, maxAttempts, err, delay);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
 /**
  * Etapa 6: Backup Storage via Supabase API
- * Agora faz backup completo: metadados + download de todos os arquivos + ZIP no padrão do Dashboard
+ * Backup completo: metadados + download de todos os arquivos + ZIP no padrão do Dashboard
  */
 module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supabaseServiceKey }) => {
   try {
@@ -18,15 +61,14 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     await ensureDir(storageDir);
 
     console.log(chalk.white(`   - ${getT('backup.steps.storage.listing')}`));
-    
-    // Usar fetch direto para Management API com Personal Access Token
+
     const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets`, {
-      headers: { 
+      headers: {
         'Authorization': `Bearer ${accessToken}`,
         'Content-Type': 'application/json'
       }
     });
-    
+
     if (!storageResponse.ok) {
       console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.listBucketsError', { status: storageResponse.status, statusText: storageResponse.statusText })}`));
       return { success: false, buckets: [] };
@@ -44,20 +86,16 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
     console.log(chalk.white(`   - ${getT('backup.steps.storage.found', { count: buckets.length })}`));
 
-    // Validar credenciais do Supabase para download de arquivos
     if (!supabaseUrl || !supabaseServiceKey) {
       console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.credentialsNotAvailable')}`));
       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);
 
@@ -67,10 +105,9 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     for (const bucket of buckets || []) {
       try {
         console.log(chalk.white(`   - ${getT('backup.steps.storage.processing', { bucketName: bucket.name })}`));
-        
-        // Listar objetos do bucket via Management API com Personal Access Token
+
         const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {
-          headers: { 
+          headers: {
             'Authorization': `Bearer ${accessToken}`,
             'Content-Type': 'application/json'
           }
@@ -90,51 +127,85 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
           objects: objects || []
         };
 
-        // Salvar informações do bucket
         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
+
+        // ── Listagem com progresso inline ──────────────────────────────
         console.log(chalk.white(`     - ${getT('backup.steps.storage.listingFiles', { bucketName: bucket.name })}`));
-        const allFiles = await listAllFilesRecursively(supabase, bucket.name, '');
-        
+        const counter = { total: 0 };
+        let allFiles = [];
+        let listingFailed = false;
+
+        try {
+          allFiles = await listAllFilesRecursively(supabase, bucket.name, '', counter, getT);
+        } catch (listErr) {
+          listingFailed = true;
+          console.log(chalk.yellow(`     ⚠️  ${getT('backup.steps.storage.listFailed', { bucketName: bucket.name, message: listErr.message })}`));
+        } finally {
+          // Encerra a linha de progresso (\r) iniciada por listAllFilesRecursively
+          process.stdout.write('\n');
+        }
+
+        if (!listingFailed) {
+          console.log(chalk.white(`     - ${getT('backup.steps.storage.totalFound', { count: allFiles.length })}`));
+        }
+
+        // ── Download com retry ──────────────────────────────────────────
         let filesDownloaded = 0;
+        let filesSkipped = 0;
+
         if (allFiles.length > 0) {
           console.log(chalk.white(`     - ${getT('backup.steps.storage.downloading', { count: allFiles.length, bucketName: 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);
+              let fileData = null;
+              let downloadError = null;
+
+              await withRetry(
+                async () => {
+                  const result = await withTimeout(
+                    supabase.storage.from(bucket.name).download(filePath),
+                    TIMEOUT_DOWNLOAD_MS
+                  );
+                  // Erros estruturais do Supabase (ex.: 404) não devem ser retentados
+                  if (result.error) {
+                    downloadError = result.error;
+                    fileData = null;
+                  } else {
+                    fileData = result.data;
+                    downloadError = null;
+                  }
+                },
+                MAX_RETRIES,
+                RETRY_BASE_DELAY_MS,
+                (attempt, max, err, delay) => {
+                  console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.downloadRetry', { path: filePath, attempt, max, delay: delay / 1000 })}`));
+                }
+              );
 
               if (downloadError) {
+                filesSkipped++;
                 console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.downloadError', { path: filePath, message: 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);
+              await ensureDir(path.dirname(localFilePath));
 
-              // Salvar arquivo localmente
-              const arrayBuffer = await fileData.arrayBuffer();
-              const buffer = Buffer.from(arrayBuffer);
+              const buffer = Buffer.from(await fileData.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(`       - ${getT('backup.steps.storage.downloaded', { current: filesDownloaded, total: allFiles.length })}`));
               }
             } catch (fileError) {
-              console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processFileError', { path: filePath, message: fileError.message })}`));
+              filesSkipped++;
+              console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.downloadFailed', { path: filePath, message: fileError.message })}`));
             }
           }
         }
@@ -143,37 +214,36 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
         processedBuckets.push({
           name: bucket.name,
           objectCount: objects?.length || 0,
-          filesDownloaded: filesDownloaded,
+          filesDownloaded,
+          filesSkipped,
           totalFiles: allFiles.length
         });
 
-        console.log(chalk.green(`     ✅ ${getT('backup.steps.storage.bucketDone', { bucketName: bucket.name, downloaded: filesDownloaded, total: allFiles.length })}`));
+        if (filesSkipped > 0) {
+          console.log(chalk.yellow(`     ⚠️  ${getT('backup.steps.storage.bucketDoneWithSkips', { bucketName: bucket.name, downloaded: filesDownloaded, skipped: filesSkipped, total: allFiles.length })}`));
+        } else {
+          console.log(chalk.green(`     ✅ ${getT('backup.steps.storage.bucketDone', { bucketName: bucket.name, downloaded: filesDownloaded, total: allFiles.length })}`));
+        }
       } catch (error) {
         console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.processBucketError', { bucketName: bucket.name, message: error.message })}`));
       }
     }
 
-    // Criar ZIP no padrão do Dashboard: {project-id}.storage.zip
+    // ── Criar ZIP no padrão do Dashboard ───────────────────────────────
     console.log(chalk.white(`\n   - ${getT('backup.steps.storage.creatingZip')}`));
     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(`   ✅ ${getT('backup.steps.storage.zipCreated', { fileName: zipFileName, size: zipSizeMB })}`));
 
-    // Perguntar ao usuário se deseja limpar a estrutura temporária
     const shouldCleanup = await confirm(`   ${getT('backup.steps.storage.cleanup')}`, false);
-    
+
     if (shouldCleanup) {
       console.log(chalk.white(`   - ${getT('backup.steps.storage.cleanupRemoving')}`));
       try {
@@ -187,11 +257,11 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     }
 
     console.log(chalk.green(`✅ ${getT('backup.steps.storage.done', { buckets: processedBuckets.length, files: totalFilesDownloaded })}`));
-    return { 
-      success: true, 
+    return {
+      success: true,
       buckets: processedBuckets,
       zipFile: zipFileName,
-      zipSizeMB: zipSizeMB,
+      zipSizeMB,
       totalFiles: totalFilesDownloaded,
       tempDirCleaned: shouldCleanup
     };
@@ -202,8 +272,10 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
   }
 };
 
+// ── Funções auxiliares ────────────────────────────────────────────────────────
+
 /**
- * Backup apenas de metadados (fallback quando não há credenciais do Supabase)
+ * Backup apenas de metadados (fallback sem credenciais Supabase)
  */
 async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
   const processedBuckets = [];
@@ -211,9 +283,9 @@ async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
   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: { 
+        headers: {
           'Authorization': `Bearer ${accessToken}`,
           'Content-Type': 'application/json'
         }
@@ -236,11 +308,7 @@ async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
       const bucketPath = path.join(storageDir, `${bucket.name}.json`);
       await writeJson(bucketPath, bucketInfo);
 
-      processedBuckets.push({
-        name: bucket.name,
-        objectCount: objects?.length || 0
-      });
-
+      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}`));
@@ -252,59 +320,97 @@ async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
 }
 
 /**
- * Lista todos os arquivos recursivamente de um bucket do Storage
+ * Lista recursivamente todos os arquivos de um bucket com:
+ * - progresso inline via \r (pasta atual + total encontrado)
+ * - timeout por chamada (TIMEOUT_LIST_MS)
+ * - retry com backoff exponencial (MAX_RETRIES)
+ *
+ * O CALLER é responsável por emitir \n após o retorno para encerrar a linha \r.
+ *
+ * @param {object} supabase
+ * @param {string} bucketName
+ * @param {string} folderPath
+ * @param {{ total: number }} counter - Contador compartilhado entre chamadas recursivas
+ * @param {Function} getT - Função de tradução
+ * @returns {Promise<string[]>}
  */
-async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
+async function listAllFilesRecursively(supabase, bucketName, folderPath = '', counter = { total: 0 }, getT) {
   const allFiles = [];
-  const getT = global.smoonbI18n?.t || t;
-  
+  const label = folderPath ? `${bucketName}/${folderPath}` : `${bucketName}/`;
+  const displayLabel = label.length > 55 ? `...${label.slice(-52)}` : label;
+
+  // Progresso inline: mostra pasta atual + arquivos encontrados até agora
+  process.stdout.write(
+    chalk.gray(`\r       → ${getT('backup.steps.storage.scanningFolder', { path: displayLabel, count: counter.total })}          `)
+  );
+
+  let result;
   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' }
-      });
+    result = await withRetry(
+      () => withTimeout(
+        supabase.storage.from(bucketName).list(folderPath, {
+          limit: 1000,
+          sortBy: { column: 'name', order: 'asc' }
+        }),
+        TIMEOUT_LIST_MS
+      ),
+      MAX_RETRIES,
+      RETRY_BASE_DELAY_MS,
+      (attempt, max, err, delay) => {
+        // Encerra linha \r antes de imprimir o aviso
+        process.stdout.write('\n');
+        console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.listRetry', { path: displayLabel, attempt, max, delay: delay / 1000, message: err.message })}`));
+      }
+    );
+  } catch (err) {
+    // Esgotou as tentativas — propaga para o caller lidar
+    throw err;
+  }
 
-    if (error) {
-      console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.listError', { path: folderPath || 'raiz', message: error.message })}`));
-      return allFiles;
-    }
+  const { data: items, error } = result;
 
-    if (!items || items.length === 0) {
-      return allFiles;
-    }
+  if (error) {
+    process.stdout.write('\n');
+    console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.listError', { path: label, message: error.message })}`));
+    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);
-      }
+  if (!items || items.length === 0) {
+    return allFiles;
+  }
+
+  for (const item of items) {
+    const itemPath = folderPath ? `${folderPath}/${item.name}` : item.name;
+
+    if (item.id === null) {
+      // Pasta — listar recursivamente
+      const subFiles = await listAllFilesRecursively(supabase, bucketName, itemPath, counter, getT);
+      allFiles.push(...subFiles);
+    } else {
+      // Arquivo
+      allFiles.push(itemPath);
+      counter.total++;
+      // Atualizar display com novo total
+      const dl = label.length > 55 ? `...${label.slice(-52)}` : label;
+      process.stdout.write(
+        chalk.gray(`\r       → ${getT('backup.steps.storage.scanningFolder', { path: dl, count: counter.total })}          `)
+      );
     }
-  } catch (error) {
-    console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processError', { path: folderPath || 'raiz', message: error.message })}`));
   }
 
   return allFiles;
 }
 
 /**
- * Adiciona um diretório recursivamente ao ZIP mantendo a estrutura de pastas
+ * Adiciona diretório recursivamente ao ZIP mantendo 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 {
@@ -313,4 +419,3 @@ async function addDirectoryToZip(zip, dirPath, basePath = '') {
     }
   }
 }
-

package/src/i18n/locales/en.json

@@ -435,9 +435,16 @@
   "backup.steps.storage.found": "Found {count} buckets",
   "backup.steps.storage.processing": "Processing bucket: {bucketName}",
   "backup.steps.storage.listingFiles": "Listing files from bucket {bucketName}...",
+  "backup.steps.storage.scanningFolder": "Scanning {path} ({count} found)",
+  "backup.steps.storage.totalFound": "Total: {count} file(s) found",
+  "backup.steps.storage.listRetry": "Attempt {attempt}/{max} to list {path} failed ({message}). Retrying in {delay}s...",
+  "backup.steps.storage.listFailed": "Failed to list bucket {bucketName} after all attempts: {message}",
   "backup.steps.storage.downloading": "Downloading {count} file(s) from bucket {bucketName}...",
   "backup.steps.storage.downloaded": "Downloaded {current}/{total} file(s)...",
+  "backup.steps.storage.downloadRetry": "File {path}: attempt {attempt}/{max} failed. Retrying in {delay}s...",
+  "backup.steps.storage.downloadFailed": "File {path}: failed after all attempts: {message}",
   "backup.steps.storage.bucketDone": "Bucket {bucketName}: {downloaded}/{total} file(s) downloaded",
+  "backup.steps.storage.bucketDoneWithSkips": "Bucket {bucketName}: {downloaded}/{total} file(s) downloaded, {skipped} skipped",
   "backup.steps.storage.creatingZip": "Creating ZIP file in Dashboard format...",
   "backup.steps.storage.zipCreated": "ZIP file created: {fileName} ({size} MB)",
   "backup.steps.storage.cleanup": "Do you want to clean storage_temp after backup",

package/src/i18n/locales/pt-BR.json

@@ -435,9 +435,16 @@
   "backup.steps.storage.found": "Encontrados {count} buckets",
   "backup.steps.storage.processing": "Processando bucket: {bucketName}",
   "backup.steps.storage.listingFiles": "Listando arquivos do bucket {bucketName}...",
+  "backup.steps.storage.scanningFolder": "Escaneando {path} ({count} encontrado(s))",
+  "backup.steps.storage.totalFound": "Total: {count} arquivo(s) encontrado(s)",
+  "backup.steps.storage.listRetry": "Tentativa {attempt}/{max} ao listar {path} falhou ({message}). Retentando em {delay}s...",
+  "backup.steps.storage.listFailed": "Falha ao listar bucket {bucketName} após {max} tentativas: {message}",
   "backup.steps.storage.downloading": "Baixando {count} arquivo(s) do bucket {bucketName}...",
   "backup.steps.storage.downloaded": "Baixados {current}/{total} arquivo(s)...",
+  "backup.steps.storage.downloadRetry": "Arquivo {path}: tentativa {attempt}/{max} falhou. Retentando em {delay}s...",
+  "backup.steps.storage.downloadFailed": "Arquivo {path}: falhou após todas as tentativas: {message}",
   "backup.steps.storage.bucketDone": "Bucket {bucketName}: {downloaded}/{total} arquivo(s) baixado(s)",
+  "backup.steps.storage.bucketDoneWithSkips": "Bucket {bucketName}: {downloaded}/{total} arquivo(s) baixado(s), {skipped} pulado(s)",
   "backup.steps.storage.creatingZip": "Criando arquivo ZIP no padrão do Dashboard...",
   "backup.steps.storage.zipCreated": "Arquivo ZIP criado: {fileName} ({size} MB)",
   "backup.steps.storage.cleanup": "Deseja limpar storage_temp após o backup",