smoonb 0.0.84 → 0.0.86

package/package.json

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

package/src/commands/backup/steps/01-database.js

@@ -1,28 +1,54 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
-const { execSync } = require('child_process');
+const { spawn } = require('child_process');
 const { t } = require('../../../i18n');
 
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  const s = Math.floor(ms / 1000);
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  if (h > 0) return `${h}h ${m % 60}m ${s % 60}s`;
+  if (m > 0) return `${m}m ${s % 60}s`;
+  return `${s}s`;
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Etapa 1: Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
+ * Com feedback de progresso: tamanho do arquivo, velocidade e tempo decorrido.
  */
 module.exports = async ({ databaseUrl, backupDir }) => {
   try {
     const getT = global.smoonbI18n?.t || t;
     console.log(chalk.white(`   - ${getT('backup.steps.database.creating')}`));
-    
-    // Extrair credenciais da databaseUrl
+
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
-    
+
     if (!urlMatch) {
       const getT = global.smoonbI18n?.t || t;
       throw new Error(getT('error.databaseUrlInvalidSimple'));
     }
-    
+
     const [, username, password, host, port] = urlMatch;
-    
-    // Gerar nome do arquivo igual ao dashboard
+
     const now = new Date();
     const day = String(now.getDate()).padStart(2, '0');
     const month = String(now.getMonth() + 1).padStart(2, '0');
@@ -30,42 +56,124 @@ module.exports = async ({ databaseUrl, backupDir }) => {
     const hours = String(now.getHours()).padStart(2, '0');
     const minutes = String(now.getMinutes()).padStart(2, '0');
     const seconds = String(now.getSeconds()).padStart(2, '0');
-    
+
     const fileName = `db_cluster-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.backup`;
-    
-    // Usar caminho absoluto igual às Edge Functions
     const backupDirAbs = path.resolve(backupDir);
-    
-    // Comando pg_dumpall via Docker
-    const dockerCmd = [
-      'docker run --rm --network host',
-      `-v "${backupDirAbs}:/host"`,
-      `-e PGPASSWORD="${password}"`,
-      'postgres:17 pg_dumpall',
-      `-h ${host}`,
-      `-p ${port}`,
-      `-U ${username}`,
-      `-f /host/${fileName}`
-    ].join(' ');
-    
+    const outputPath = path.join(backupDirAbs, fileName);
+
+    const dockerArgs = [
+      'run', '--rm', '--network', 'host',
+      '-v', `${backupDirAbs}:/host`,
+      '-e', `PGPASSWORD=${password}`,
+      'postgres:17', 'pg_dumpall',
+      '-h', host,
+      '-p', port,
+      '-U', username,
+      '-f', `/host/${fileName}`
+    ];
+
     console.log(chalk.white(`   - ${getT('backup.steps.database.executing')}`));
-    execSync(dockerCmd, { stdio: 'pipe' });
-    
-    // Compactar igual ao Supabase Dashboard
-    const gzipCmd = [
-      'docker run --rm',
-      `-v "${backupDirAbs}:/host"`,
-      `postgres:17 gzip /host/${fileName}`
-    ].join(' ');
-    
-    execSync(gzipCmd, { stdio: 'pipe' });
-    
+
+    const startTime = Date.now();
+    let lastSize = 0;
+    let lastTime = startTime;
+    let ticker = null;
+
+    const runDump = () => new Promise((resolve, reject) => {
+      const proc = spawn('docker', dockerArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+
+      const pollFile = async () => {
+        if (!(await exists(outputPath))) return;
+        const stat = await fs.stat(outputPath).catch(() => null);
+        if (!stat) return;
+        const size = stat.size;
+        const elapsed = Date.now() - startTime;
+        const deltaTime = (Date.now() - lastTime) / 1000;
+        const speed = deltaTime > 0 ? (size - lastSize) / deltaTime : 0;
+        lastSize = size;
+        lastTime = Date.now();
+        const line = `     📦 ${formatBytes(size)} | ${formatDuration(elapsed)} | ${formatBytes(speed)}/s`;
+        process.stdout.write(`\r${line}`);
+      };
+
+      ticker = setInterval(pollFile, 500);
+
+      proc.on('close', (code) => {
+        if (ticker) {
+          clearInterval(ticker);
+          ticker = null;
+        }
+        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        if (code !== 0) {
+          reject(new Error(`pg_dumpall exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+
+      proc.on('error', (err) => {
+        if (ticker) clearInterval(ticker);
+        reject(err);
+      });
+    });
+
+    await runDump();
+
+    const gzipArgs = [
+      'run', '--rm',
+      '-v', `${backupDirAbs}:/host`,
+      'postgres:17', 'gzip', `/host/${fileName}`
+    ];
+
+    const gzipStart = Date.now();
+    let gzipTicker = null;
     const finalFileName = `${fileName}.gz`;
+    const gzipOutputPath = path.join(backupDirAbs, finalFileName);
+
+    const runGzip = () => new Promise((resolve, reject) => {
+      const proc = spawn('docker', gzipArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+
+      const pollGzip = async () => {
+        if (!(await exists(gzipOutputPath))) return;
+        const stat = await fs.stat(gzipOutputPath).catch(() => null);
+        if (!stat) return;
+        const size = stat.size;
+        const elapsed = Date.now() - gzipStart;
+        process.stdout.write(`\r     📦 ${formatBytes(size)} | ${formatDuration(elapsed)}\r`);
+      };
+
+      gzipTicker = setInterval(pollGzip, 300);
+
+      proc.on('close', (code) => {
+        if (gzipTicker) {
+          clearInterval(gzipTicker);
+          gzipTicker = null;
+        }
+        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        if (code !== 0) {
+          reject(new Error(`gzip exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+
+      proc.on('error', (err) => {
+        if (gzipTicker) clearInterval(gzipTicker);
+        reject(err);
+      });
+    });
+
+    await runGzip();
+
     const stats = await fs.stat(path.join(backupDir, finalFileName));
     const sizeKB = (stats.size / 1024).toFixed(1);
-    
+
     console.log(chalk.green(`     ✅ Database backup: ${finalFileName} (${sizeKB} KB)`));
-    
+
     return { success: true, size: sizeKB, fileName: finalFileName };
   } catch (error) {
     const getT = global.smoonbI18n?.t || t;
@@ -73,4 +181,3 @@ module.exports = async ({ databaseUrl, backupDir }) => {
     return { success: false };
   }
 };
-

package/src/commands/backup/steps/02-database-separated.js

@@ -1,9 +1,32 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
-const { execSync } = require('child_process');
+const { spawn } = require('child_process');
 const { t } = require('../../../i18n');
 
+function runWithElapsedTicker(command, args, env, label) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const ticker = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - start) / 1000);
+      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
+    }, 1000);
+    const proc = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+      env: { ...process.env, ...env }
+    });
+    proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+    proc.on('close', (code) => {
+      clearInterval(ticker);
+      process.stdout.write('\r' + ' '.repeat(60) + '\r');
+      if (code !== 0) reject(new Error(`Exited with code ${code}`));
+      else resolve();
+    });
+    proc.on('error', reject);
+  });
+}
+
 /**
  * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
  */
@@ -21,10 +44,12 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     const schemaFile = path.join(backupDir, 'schema.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`, { 
-        stdio: 'pipe', 
-        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
-      });
+      await runWithElapsedTicker(
+        `supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`,
+        [],
+        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+        getT('backup.steps.database.separated.exportingSchema')
+      );
       const stats = await fs.stat(schemaFile);
       const sizeKB = (stats.size / 1024).toFixed(1);
       files.push({ filename: 'schema.sql', sizeKB });
@@ -39,10 +64,12 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     const dataFile = path.join(backupDir, 'data.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`, { 
-        stdio: 'pipe', 
-        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
-      });
+      await runWithElapsedTicker(
+        `supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`,
+        [],
+        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+        getT('backup.steps.database.separated.exportingData')
+      );
       const stats = await fs.stat(dataFile);
       const sizeKB = (stats.size / 1024).toFixed(1);
       files.push({ filename: 'data.sql', sizeKB });
@@ -57,10 +84,12 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     const rolesFile = path.join(backupDir, 'roles.sql');
     
     try {
-      execSync(`supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`, { 
-        stdio: 'pipe', 
-        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
-      });
+      await runWithElapsedTicker(
+        `supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`,
+        [],
+        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+        getT('backup.steps.database.separated.exportingRoles')
+      );
       const stats = await fs.stat(rolesFile);
       const sizeKB = (stats.size / 1024).toFixed(1);
       files.push({ filename: 'roles.sql', sizeKB });

package/src/commands/backup/steps/07-custom-roles.js

@@ -1,11 +1,31 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
-const { promisify } = require('util');
-const { exec } = require('child_process');
+const { spawn } = require('child_process');
 const { t } = require('../../../i18n');
 
-const execAsync = promisify(exec);
+function runWithElapsedTicker(command, env, label) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const ticker = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - start) / 1000);
+      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
+    }, 1000);
+    const proc = spawn(command, [], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+      env: { ...process.env, ...env }
+    });
+    proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+    proc.on('close', (code) => {
+      clearInterval(ticker);
+      process.stdout.write('\r' + ' '.repeat(60) + '\r');
+      if (code !== 0) reject(new Error(`Exited with code ${code}`));
+      else resolve();
+    });
+    proc.on('error', reject);
+  });
+}
 
 /**
  * Etapa 7: Backup Custom Roles via SQL
@@ -16,12 +36,10 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
     console.log(chalk.white(`   - ${getT('backup.steps.roles.exporting')}`));
     
     const customRolesFile = path.join(backupDir, 'custom-roles.sql');
+    const cmd = `supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`;
     
     try {
-      // Usar Supabase CLI via Docker para roles
-      await execAsync(`supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`, { 
-        env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken || '' } 
-      });
+      await runWithElapsedTicker(cmd, { SUPABASE_ACCESS_TOKEN: accessToken || '' }, getT('backup.steps.roles.exporting'));
       
       const stats = await fs.stat(customRolesFile);
       const sizeKB = (stats.size / 1024).toFixed(1);

package/src/commands/backup/steps/08-edge-functions.js

@@ -89,12 +89,17 @@ module.exports = async (context) => {
     const downloadedFunctions = [];
     let successCount = 0;
     let errorCount = 0;
+    const totalFuncs = functions.length;
+    const stepStart = Date.now();
 
     // Baixar cada Edge Function via Supabase CLI
     // Nota: O CLI ignora o cwd e sempre baixa para supabase/functions
-    for (const func of functions) {
+    for (let idx = 0; idx < functions.length; idx++) {
+      const func = functions[idx];
+      const current = idx + 1;
+      const elapsed = Math.floor((Date.now() - stepStart) / 1000);
       try {
-        console.log(chalk.white(`   - Baixando: ${func.name}...`));
+        console.log(chalk.white(`   - Baixando ${current}/${totalFuncs}: ${func.name}... (${elapsed}s)`));
         
         // Criar diretório da função NO BACKUP
         const functionTargetDir = path.join(functionsDir, func.name);