smoonb 0.0.83 → 0.0.85

package/bin/smoonb.js

@@ -275,6 +275,7 @@ if (options.lang) {
   const newI18n = initI18n(['--lang', forcedLocale], { ...process.env, SMOONB_LANG: forcedLocale });
   i18n = newI18n;
   t = newI18n.t;
+  Object.assign(global.smoonbI18n, newI18n);
 }
 
 // Se nenhum comando foi fornecido, mostrar ajuda

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.83",
+  "version": "0.0.85",
   "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);

package/src/i18n/index.js

@@ -198,13 +198,15 @@ function loadCatalog(locale) {
  * @returns {string} - Texto traduzido
  */
 function t(id, vars = {}, locale = null) {
-  const localeToUse = locale || global.smoonbI18n?.locale || 'en';
-  const catalog = loadCatalog(localeToUse);
+  // Determinar locale a usar
+  const catalog = locale ? loadCatalog(locale) : (global.smoonbI18n?.catalog || loadCatalog('en'));
 
+  // Buscar tradução
   let translation = catalog[id] || id;
 
+  // Substituir placeholders nomeados (ex: {name}, {path})
   if (typeof translation === 'string' && Object.keys(vars).length > 0) {
-    translation = translation.replace(/\{(\w+)\}/g, (match, key) => {
+    translation = translation.replace(/{(\w+)}/g, (match, key) => {
       return vars[key] !== undefined ? String(vars[key]) : match;
     });
   }
@@ -212,16 +214,6 @@ function t(id, vars = {}, locale = null) {
   return translation;
 }
 
-let globalTranslator = null;
-
-function ensureGlobalTranslator() {
-  if (!globalTranslator) {
-    globalTranslator = (id, vars) => t(id, vars, global.smoonbI18n?.locale);
-  }
-
-  return globalTranslator;
-}
-
 /**
  * Inicializar i18n com locale detectado
  * @param {string[]} argv - Argumentos da linha de comando
@@ -232,13 +224,12 @@ function initI18n(argv = process.argv, env = process.env) {
   const locale = detectLocale(argv, env);
   const catalog = loadCatalog(locale);
 
-  if (!global.smoonbI18n) {
-    global.smoonbI18n = {};
-  }
-
-  global.smoonbI18n.locale = locale;
-  global.smoonbI18n.catalog = catalog;
-  global.smoonbI18n.t = ensureGlobalTranslator();
+  // Armazenar globalmente para acesso fácil
+  global.smoonbI18n = {
+    locale,
+    catalog,
+    t: (id, vars) => t(id, vars, locale)
+  };
 
   return global.smoonbI18n;
 }

package/src/i18n/locales/en.json

@@ -266,7 +266,7 @@
   "env.language.english": "English",
   "env.language.portuguese": "Portuguese (pt-BR)",
   "env.language.saved": "Default language saved: {lang}",
-  "env.language.applied": "Language applied! The next messages will be displayed in the selected language.",
+  "env.language.note": "Note: The language change will be effective in the next commands. The current process will continue in the initial language.",
 
   "backup.components.edgeFunctions.title": "Edge Functions:",
   "backup.components.edgeFunctions.description1": "We will delete existing functions in the supabase/functions folder, reset the link",

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

@@ -266,7 +266,7 @@
   "env.language.english": "Inglês (English)",
   "env.language.portuguese": "Português (pt-BR)",
   "env.language.saved": "Idioma padrão salvo: {lang}",
-  "env.language.applied": "Idioma aplicado! As próximas mensagens serão exibidas no idioma selecionado.",
+  "env.language.note": "Nota: A mudança de idioma será efetiva nos próximos comandos. O processo atual continuará no idioma inicial.",
 
   "backup.components.edgeFunctions.title": "Edge Functions:",
   "backup.components.edgeFunctions.description1": "Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link",

package/src/interactive/envMapper.js

@@ -84,12 +84,7 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
     };
   }
 
-  // Função getT que sempre acessa global.smoonbI18n dinamicamente
-  // Isso permite que a mudança de idioma seja aplicada em tempo real
-  const getT = (id, vars) => {
-    const currentT = global.smoonbI18n?.t || t;
-    return currentT(id, vars);
-  };
+  const getT = global.smoonbI18n?.t || t;
   
   for (const expected of expectedKeys) {
     console.log(chalk.blue(`\n🔧 ${getT('env.mapping.title', { variable: expected })}`));
@@ -238,27 +233,15 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
     }]);
 
     finalEnv.SMOONB_LANG = selectedLang;
-    
-    // Re-inicializar i18n com o novo idioma para aplicar mudança em tempo real
-    const { initI18n } = require('../i18n');
-    initI18n(process.argv, { ...process.env, SMOONB_LANG: selectedLang });
-    
-    // getT agora funciona dinamicamente, sempre acessando global.smoonbI18n?.t
-    // Então não precisamos atualizar nada, apenas usar getT normalmente
     console.log(chalk.green(`✅ ${getT('env.language.saved', { lang: selectedLang })}`));
-    console.log(chalk.cyan(`🌐 ${getT('env.language.applied')}`));
+    console.log(chalk.yellow(`💡 ${getT('env.language.note')}`));
   }
 
   return { finalEnv, dePara };
 }
 
 async function askComponentsFlags() {
-  // Função getT que sempre acessa global.smoonbI18n dinamicamente
-  // Isso permite que a mudança de idioma seja aplicada em tempo real
-  const getT = (id, vars) => {
-    const currentT = global.smoonbI18n?.t || t;
-    return currentT(id, vars);
-  };
+  const getT = global.smoonbI18n?.t || t;
   
   // Explicação sobre Edge Functions
   console.log(chalk.cyan(`\n⚡ ${getT('backup.components.edgeFunctions.title')}`));